hatcher

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file tools.license for terms.
 
#ifndef tools_hatcher
#define tools_hatcher
 
#include "lina/vec3f"
#include "lina/vec2f"
#include "mathf"
#include <cfloat> // for FLT_MAX
 
namespace tools {
 
class hatcher {
public:
  hatcher()
  :fShift(.1f)
  ,fDirAngle(fpi()/4)
  ,fOffsetValue(.0f)
  ,fOffset(vec3f(FLT_MAX,FLT_MAX,FLT_MAX))
  ,fPrecisionFactor (.0001f) // good value to get rid of some errors
  ,fStripWidth(0.0)
  ,fFirstNumHatch(0)
  ,fNumberHatchToDraw(0)
  ,fFirstPolyline(true)
  ,fResolveResult(RESOLVE_UNDEFINED)
  {}
  virtual ~hatcher() {}
protected:
  hatcher(const hatcher& a_from)
  :fNormal(a_from.fNormal)
  ,fShift(a_from.fShift)
  ,fDirAngle(a_from.fDirAngle)
  ,fOffsetValue(a_from.fOffsetValue)
  ,fOffset(a_from.fOffset)
  ,fShiftVec(a_from.fShiftVec)
  ,fPrecisionFactor(a_from.fPrecisionFactor)
  ,fDirVec(a_from.fDirVec)
  ,fStripWidth(a_from.fStripWidth)
  ,fPoints(a_from.fPoints)
  ,fVertices(a_from.fVertices)
  ,fConflictNumHatchLineTab(a_from.fConflictNumHatchLineTab)
  ,fHatchShiftToMatchPointVec(a_from.fHatchShiftToMatchPointVec)
  ,fFirstNumHatch(a_from.fFirstNumHatch)
  ,fNumberHatchToDraw(a_from.fNumberHatchToDraw)
  ,fFirstPolyline(a_from.fFirstPolyline)
  ,fResolveResult(a_from.fResolveResult)
  {}
  hatcher& operator=(const hatcher& a_from){
    fNormal = a_from.fNormal;
    fShift = a_from.fShift;
    fDirAngle = a_from.fDirAngle;
    fOffsetValue = a_from.fOffsetValue;
    fOffset = a_from.fOffset;
    fShiftVec = a_from.fShiftVec;
    fPrecisionFactor = a_from.fPrecisionFactor;
    fDirVec = a_from.fDirVec;
    fStripWidth = a_from.fStripWidth;
    fPoints = a_from.fPoints;
    fVertices = a_from.fVertices;
    fConflictNumHatchLineTab = a_from.fConflictNumHatchLineTab;
    fHatchShiftToMatchPointVec = a_from.fHatchShiftToMatchPointVec;
    fFirstNumHatch = a_from.fFirstNumHatch;
    fNumberHatchToDraw = a_from.fNumberHatchToDraw;
    fFirstPolyline = a_from.fFirstPolyline;
    fResolveResult = a_from.fResolveResult;
    return *this;
  }
public:
  bool compute_polyline (vec3f* listPoints,unsigned int number);
 
 
  bool check_polyline(vec3f* listPoints,unsigned int number);
 
  void set_spacing(float a) {fShift = a;}       //set the spacing for this hatch.
  void set_angle(float a) {fDirAngle = a;}      //set the Direction angle for the hatch in radians.
  void set_offset(float a) {fOffsetValue = a;}  //set the offset value for this hatch.
  void set_offset_point(vec3f a) {fOffset = a;}  //set the offset Point for this hatch.
  void set_precision_factor(float a) {fPrecisionFactor = a;} //set the precision factor for computing (0.0001 is default).
 
  bool set_strip_width(float a) {
    // set the strip width value(0 is default and means no strip).
    if (a<0 || a>1) {
      fStripWidth = 0;
      return false;
    }
    fStripWidth = a;
    return true;
  }
 
  float get_spacing()const {return fShift;}
  float get_angle()const {return fDirAngle;}
  float get_offset()const {return fOffsetValue;}
  const vec3f& get_offset_point() {return fOffset;}
  float get_precision_factor()const {return fPrecisionFactor;}
  float get_strip_width()const {return fStripWidth;}
  const vec3f& get_normal() {return fNormal;}
 
  //size_t number_of_points() const {return fPoints.size();} //get the number of points compute for this hatch.
  const std::vector<vec3f>& points() {return fPoints;}
 
  //size_t number_of_vertices() const {return fVertices.size();} //get the number of vertices compute for this hatch.
  const std::vector<unsigned int>& vertices() {return fVertices;}
 
protected:
 
  bool compute_single_polyline (vec3f* listPoints,unsigned int number);
 
 
  vec2f resolve_system(const vec3f& A,const vec3f& B,const vec3f& C);
 
 
protected:
  vec3f fNormal;
 
  float fShift; // Absloute distance between two hatch in the polyline plan  */
 
  float fDirAngle;
 
  float fOffsetValue;
 
  vec3f fOffset;
 
  vec3f fShiftVec;
 
  float fPrecisionFactor;
 
  vec3f  fDirVec;
 
  float fStripWidth;
 
  std::vector<vec3f> fPoints;
 
  std::vector<unsigned int> fVertices;
 
  std::vector< std::vector<int> > fConflictNumHatchLineTab;
 
  std::vector<float> fHatchShiftToMatchPointVec;
 
  int fFirstNumHatch;
 
  unsigned int fNumberHatchToDraw;
 
  bool fFirstPolyline;
  enum ResolveErrors{
    RESOLVE_OK = 0,
    RESOLVE_COLINEAR,
    RESOLVE_Z_ERROR,
    RESOLVE_PRECISION_ERROR,
    RESOLVE_UNDEFINED
  };
  ResolveErrors fResolveResult;
};
 
}
 
#include "hatcher.icc"
 
#endif