src/lib/assembly.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 __ASSEMBLY_H__
#define __ASSEMBLY_H__

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

#include <vector>

// this vailue is used for transformation to specify unplaced pieces
#define UNPLACED_TRANS 0xff

class problem_c;
class voxel_c;
class xmlWriter_c;
class xmlParser_c;

class placement_c {

public:

  unsigned char transformation;

  int xpos, ypos, zpos;

  placement_c(unsigned char tran, int x, int y, int z) : transformation(tran), xpos(x), ypos(y), zpos(z) {}
  placement_c(const placement_c * orig) : transformation(orig->transformation), xpos(orig->xpos), ypos(orig->ypos), zpos(orig->zpos) {}
  placement_c(const placement_c & orig) : transformation(orig.transformation), xpos(orig.xpos), ypos(orig.ypos), zpos(orig.zpos) {}

  int getX(void) const { return xpos; }
  int getY(void) const { return ypos; }
  int getZ(void) const { return zpos; }
  unsigned char getTransformation(void) const  { return transformation; }

  bool operator == (const placement_c & b) const {
    return ((transformation == b.transformation) &&
            (xpos == b.xpos) && (ypos == b.ypos) && (zpos == b.zpos));
  }

  placement_c & operator = (const placement_c & b) {
    transformation = b.transformation;
    xpos = b.xpos;
    ypos = b.ypos;
    zpos = b.zpos;
    return *this;
  }

  bool operator < (const placement_c & b) const {
    if (transformation < b.transformation) return true;
    if (transformation > b.transformation) return false;

    if (xpos < b.xpos) return true;
    if (xpos > b.xpos) return false;

    if (ypos < b.ypos) return true;
    if (ypos > b.ypos) return false;

    if (zpos < b.zpos) return true;
    if (zpos > b.zpos) return false;

    return false;
  }
};

class mirrorInfo_c {

  typedef struct {
    unsigned int pc1;     //< first piece involved
    unsigned int pc2;     //< second piece which is the mirror piece of pc1

    unsigned char trans;  //< how to transform pc1 onto pc2
  } entry;

  std::vector<entry> entries;

  public:

    mirrorInfo_c(void) {};

    void addPieces(unsigned int p1, unsigned int p2, unsigned char trans);

    bool getPieceInfo(unsigned int p, unsigned int * p_out, unsigned char * trans) const;

private:

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

class assembly_c {

private:

  std::vector<placement_c> placements;

  const symmetries_c * sym;

  bool operator == (const assembly_c & b) const {
    /* two assemblies are equal if all placements and transformations
     * of all pieces are identical
     * Comparisons are only possible, when the two assemblies
     * have the same number of pieces
     */
    bt_assert(placements.size() == b.placements.size());

    for (unsigned int i = 0; i < placements.size(); i++)
      if (!(placements[i] == b.placements[i]))
        return false;

    return true;
  }

  bool compare(const assembly_c & b, unsigned int pivot) const;

  bool containsMirroredPieces(void) const;

  bool validSolution(const problem_c * puz) const;

public:

  assembly_c(const gridType_c * gt) : sym(gt->getSymmetries()) {}

  assembly_c(const assembly_c * orig);

  assembly_c(xmlParser_c & pars, unsigned int pieces, const gridType_c * gt);

  void save(xmlWriter_c & xml) const;

  void addPlacement(unsigned char tran, int x, int y, int z) {
    bt_assert(tran < sym->getNumTransformations());
    bt_assert(tran != UNPLACED_TRANS);
    placements.push_back(placement_c(tran, x, y, z));
  }

  void addNonPlacement(void) {
    placements.push_back(placement_c(UNPLACED_TRANS, 0, 0, 0));
  }

  unsigned int placementCount(void) const { return placements.size(); }

  bool isPlaced(unsigned int num) const {
    return placements[num].getTransformation() != UNPLACED_TRANS;
  }

  unsigned char getTransformation(unsigned int num) const {
    bt_assert(num < placements.size());
    bt_assert(placements[num].getTransformation() != UNPLACED_TRANS);
    return placements[num].getTransformation();
  }

  int getX(unsigned int num) const {
    bt_assert(num < placements.size());
    bt_assert(placements[num].getTransformation() != UNPLACED_TRANS);
    return placements[num].getX();
  }

  int getY(unsigned int num) const {
    bt_assert(num < placements.size());
    bt_assert(placements[num].getTransformation() != UNPLACED_TRANS);
    return placements[num].getY();
  }

  int getZ(unsigned int num) const {
    bt_assert(num < placements.size());
    bt_assert(placements[num].getTransformation() != UNPLACED_TRANS);
    return placements[num].getZ();
  }

  bool transform(unsigned char trans, const problem_c * puz, const mirrorInfo_c * mir);

  bool smallerRotationExists(const problem_c * puz, unsigned int pivot, const mirrorInfo_c * mir, bool complete) const;

  void exchangeShape(unsigned int s1, unsigned int s2);

  int comparePieces(const assembly_c * b) const;

  void sort(const problem_c * puz);

  voxel_c * createSpace(const problem_c * puz) const;

  void removePieces(unsigned int from, unsigned int cnt);

  void addNonPlacedPieces(unsigned int from, unsigned int cnt);

private:

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

};

#endif

---