src/lib/voxel.h

Go to the documentation of this file.

/* BurrTools
 *
 * BurrTools is the legal property of its developers, whose
 * names are listed in the COPYRIGHT file, which is included
 * within the source distribution.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#ifndef __VOXEL_H__
#define __VOXEL_H__

#include "bt_assert.h"
#include "symmetries.h"
#include "gridtype.h"
#include "types.h"

#include <stdio.h>
#include <string>

class xmlWriter_c;
class xmlParser_c;
class Polyhedron;

class voxel_c {

protected:

  const gridType_c *gt;

  unsigned int sx; 
  unsigned int sy; 
  unsigned int sz; 

  unsigned int voxels;

  voxel_type * space;

  unsigned int bx1; 
  unsigned int bx2; 
  unsigned int by1; 
  unsigned int by2; 
  unsigned int bz1; 
  unsigned int bz2; 
  bool doRecalc;    

  mutable symmetries_t symmetries;

  int hx; 
  int hy; 
  int hz; 

  std::string name;

  int weight;

  int * BbHsCache;

protected:

  void recalcBoundingBox(void);

public:

  typedef enum {
    VX_EMPTY,   
    VX_FILLED,  
    VX_VARIABLE 
  } VoxelState;

  void skipRecalcBoundingBox(bool skipit) {
    if (skipit)
      doRecalc = false;
    else {
      doRecalc = true;
      recalcBoundingBox();
    }
  }

public:

  voxel_c(unsigned int x, unsigned int y, unsigned int z, const gridType_c * gt, voxel_type init = 0);

  voxel_c(xmlParser_c & pars, const gridType_c * gt);

  voxel_c(const voxel_c & orig);

  voxel_c(const voxel_c * orig);

  virtual ~voxel_c();

  void copy(const voxel_c * orig);

  unsigned int getX(void) const { return sx; } 
  unsigned int getY(void) const { return sy; } 
  unsigned int getZ(void) const { return sz; } 

  const gridType_c * getGridType(void) const { return gt; }

  unsigned int getDiagonal(void) const { return sx*sx + sy*sy + sz*sz; }

  unsigned int getBiggestDimension(void) const {
    if (sx > sy)
      if (sz > sx)
        return sz;
      else
        return sx;
    else
      if (sz > sy)
        return sz;
      else
        return sy;
  }

  unsigned int getXYZ(void) const { return voxels; }

  int getIndex(unsigned int x, unsigned int y, unsigned int z) const {
    bt_assert((x<sx)&&(y<sy)&&(z<sz));
    return x + sx * (y + sy * z);
  }

  bool indexToXYZ(unsigned int index, unsigned int *x, unsigned int *y, unsigned int *z) const;

  voxel_type get(unsigned int x, unsigned int y, unsigned int z) const {
    return space[getIndex(x, y, z)];
  }

  voxel_type get2(int x, int y, int z) const {
    if ((x>=0)&&(y>=0)&&(z>=0)&&((long)x<(long)sx)&&((long)y<(long)sy)&&((long)z<(long)sz))
      return space[getIndex(x, y, z)];
    else
      return VX_EMPTY;
  }

  voxel_type get(unsigned int p) const {
    bt_assert(p<voxels);
    return space[p];
  }

  bool neighbour(unsigned int p, voxel_type val) const;

  virtual bool getNeighbor(unsigned int idx, unsigned int typ, int x, int y, int z, int * xn, int *yn, int *zn) const = 0;

  void set(unsigned int x, unsigned int y, unsigned int z, voxel_type val) {
    space[getIndex(x, y, z)] = val;
    recalcBoundingBox();
    symmetries = symmetryInvalid();
  }

  void set(unsigned int p, voxel_type val) {
    bt_assert(p<voxels);
    space[p] = val;
    recalcBoundingBox();
    symmetries = symmetryInvalid();
  }

  void setAll(voxel_type val) {
    memset(space, val, voxels);
    recalcBoundingBox();
    symmetries = symmetryInvalid();
  }

  unsigned int count(voxel_type val) const;

  virtual void transformPoint(int * x, int * y, int * z, unsigned int trans) const = 0;

  void translate(int dx, int dy, int dz, voxel_type filler);

  virtual void minimizePiece(void);

  unsigned int boundX1(void) const { return bx1; } 
  unsigned int boundX2(void) const { return bx2; } 
  unsigned int boundY1(void) const { return by1; } 
  unsigned int boundY2(void) const { return by2; } 
  unsigned int boundZ1(void) const { return bz1; } 
  unsigned int boundZ2(void) const { return bz2; } 

  bool getBoundingBox(unsigned char trans, int * x1, int * y1, int * z1, int * x2 = 0, int * y2 = 0, int * z2 = 0) const;

  bool operator == (const voxel_c & op) const;

  virtual bool identicalInBB(const voxel_c * op, bool includeColors = true) const;

  bool identicalWithRots(const voxel_c * op, bool includeMirror, bool includeColors) const;

  unsigned char getMirrorTransform(const voxel_c * op) const;

  void resize(unsigned int nsx, unsigned int nsy, unsigned int nsz, voxel_type filler);

  virtual void resizeInclude(int & px, int & py, int & pz) = 0;

  virtual void scale(unsigned int amount, bool grid = false);

  virtual bool scaleDown(unsigned char by, bool action);

  private:

  void unionFind(int * tree, char type, bool inverse, voxel_type value, bool outsideZ) const;

  public:

  bool connected(char type, bool inverse, voxel_type value, bool outsideZ = true) const;

  void fillHoles(char type);

  virtual bool transform(unsigned int nr) = 0;

  symmetries_t selfSymmetries(void) const;

  unsigned char normalizeTransformation(unsigned char trans) const {
    return gt->getSymmetries()->minimizeTransformation(selfSymmetries(), trans);
  }


public:


  int getState(unsigned int x, unsigned int y, unsigned int z) const { return get(x, y, z) & 0x3; }
  int getState2(int x, int y, int z) const { return get2(x, y, z) & 0x3; }
  int getState(unsigned int i) const { return get(i) & 0x3; }
  unsigned int getColor(unsigned int x, unsigned int y, unsigned int z) const { return get(x, y, z) >> 2; }
  unsigned int getColor2(int x, int y, int z) const { return get2(x, y, z) >> 2; }
  unsigned int getColor(unsigned int i) const { return get(i) >> 2; }


  bool isEmpty(unsigned int x, unsigned int y, unsigned int z) const { return getState(x, y, z) == VX_EMPTY; }
  bool isEmpty2(int x, int y, int z) const { return getState2(x, y, z) == VX_EMPTY; }
  bool isEmpty(unsigned int i) const { return getState(i) == VX_EMPTY; }
  bool isFilled(unsigned int x, unsigned int y, unsigned int z) const { return getState(x, y, z) == VX_FILLED; }
  bool isFilled2(int x, int y, int z) const { return getState2(x, y, z) == VX_FILLED; }
  bool isFilled(unsigned int i) const { return getState(i) == VX_FILLED; }
  bool isVariable(unsigned int x, unsigned int y, unsigned int z) const { return getState(x, y, z) == VX_VARIABLE; }
  bool isVariable2(int x, int y, int z) const { return getState2(x, y, z) == VX_VARIABLE; }
  bool isVariable(unsigned int i) const { return getState(i) == VX_VARIABLE; }


  void setState(unsigned int x, unsigned int y, unsigned int z, int state) { set(x, y, z, (get(x, y, z) & ~0x3) | state); }
  void setColor(unsigned int x, unsigned int y, unsigned int z, unsigned int color) { bt_assert(color < 64); set(x, y, z, (get(x, y, z) & 0x3) | color << 2); }
  void setState(unsigned int i, int state) { set(i, (get(i) & ~0x3) | state); }
  void setColor(unsigned int i, unsigned int color) { bt_assert(color < 64); set(i, (get(i) & 0x3) | color << 2); }

  unsigned int countState(int state) const;


  typedef enum {
    ACT_FIXED,    
    ACT_VARIABLE, 
    ACT_DECOLOR   
  } VoxelAction;

  void actionOnSpace(VoxelAction action, bool inside);

  void save(xmlWriter_c & xml) const;

  int getHx(void) const { return hx; } 
  int getHy(void) const { return hy; } 
  int getHz(void) const { return hz; } 
  void setHotspot(int x, int y, int z); 

  virtual void initHotspot(void);

  bool getHotspot(unsigned char trans, int * x, int * y, int * z) const;

  const std::string & getName(void) const { return name; }

  void setName(const std::string & n) { name = n; }

  int getWeight(void) const { return weight; } 
  void setWeight(int w) { weight = w; }        

  virtual bool validCoordinate(int x, int y, int z) const = 0;

  /* creates the intersection of the 2 given voxel spaces and
   * unifies the result with this voxel space
   *
   * it returns true, if there were voxels added
   */
  bool unionintersect(
      const voxel_c * va, int xa, int ya, int za,
      const voxel_c * vb, int xb, int yb, int zb
      );

  virtual bool onGrid(int x, int y, int z) const = 0;

  virtual Polyhedron * getMesh(double bevel, double offset) const;

  /* return true, when the given parameters will result in a usable
   * polyhedron, when offset or bevel gets too big return false
   */
  virtual bool meshParamsValid(double /*bevel*/, double /*offset*/) const { return true; }

  virtual Polyhedron * getDrawingMesh(void) const;

  virtual Polyhedron * getWireframeMesh(void) const;

  virtual void getConnectionFace(int /*x*/, int /*y*/, int /*z*/, int /*n*/, double /*bevel*/, double /*offset*/, std::vector<float> & /*faceCorners*/) const {};

  virtual void calculateSize(float * x, float * y, float * z) const { *x = 0; *y = 0; *z = 0; }


  virtual void recalcSpaceCoordinates(float * /*x*/, float * /*y*/, float * /*z*/) const {}

private:

  virtual Polyhedron * getMeshInternal(double bevel, double offset, bool fast) const;

  // no copying and assigning
  void operator=(const voxel_c&);

};

/* some defines used for the flags of the faces of the generated meshes
 */

#define FF_COLOR_LIGHT    0x01 // this helps with the colorisation
#define FF_VARIABLE_MARK  0x02 // when set, the face is supposed to be with a variable marker
#define FF_VARIABLE_FACE  0x04 // when set, the face itself is the variable marker only one or none of these 2 should be set
#define FF_WIREFRAME      0x08 // when set, the face stays when in wire frame more
#define FF_BEVEL_FACE     0x10 // the face got added because the polyhedron has a bevel
#define FF_OFFSET_FACE    0x20 // the face is added because the polyhedron has an offset
#define FF_PROCESSED_FACE 0x40 // tags faces already processed by the polygon fill routine
#define FF_INSIDE_FACE    0x80 // tags faces already processed by the polygon fill routine

#endif

---