Sketch.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) Jürgen Riegel          (juergen.riegel@web.de) 2010     *
 *                                                                         *
 *   This file is part of the FreeCAD CAx development system.              *
 *                                                                         *
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU Library General Public           *
 *   License as published by the Free Software Foundation; either          *
 *   version 2 of the License, or (at your option) any later version.      *
 *                                                                         *
 *   This library  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 Library General Public License for more details.                  *
 *                                                                         *
 *   You should have received a copy of the GNU Library General Public     *
 *   License along with this library; see the file COPYING.LIB. If not,    *
 *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
 *   Suite 330, Boston, MA  02111-1307, USA                                *
 *                                                                         *
 ***************************************************************************/

#ifndef SKETCHER_SKETCH_H
#define SKETCHER_SKETCH_H

#include <App/PropertyStandard.h>
#include <App/PropertyFile.h>
#include <Mod/Part/App/Geometry.h>
#include <Mod/Part/App/TopoShape.h>
#include "Constraint.h"

#include "freegcs/GCS.h"

#include <Base/Persistence.h>

namespace Sketcher
{

class SketcherExport Sketch :public Base::Persistence
{
    TYPESYSTEM_HEADER();

public:
    Sketch();
    ~Sketch();

    // from base class
    virtual unsigned int getMemSize(void) const;
    virtual void Save(Base::Writer &/*writer*/) const;
    virtual void Restore(Base::XMLReader &/*reader*/);

    int solve(void);
    void clear(void);
    int setUpSketch(const std::vector<Part::Geometry *> &GeoList,const std::vector<Constraint *> &ConstraintList,
                    bool withDiagnose=true);
    Part::TopoShape toShape(void) const;
    int addGeometry(const Part::Geometry *geo);
    void addGeometry(const std::vector<Part::Geometry *> &geo);
    std::vector<Part::Geometry *> getGeometry(bool withConstrucionElements = true) const;
    Py::Tuple getPyGeometry(void) const;
    void setConstruction(int geoIndex,bool isConstruction=true);
    bool getConstruction(int geoIndex) const;

    int getPointId(int geoId, PointPos pos) const;
    Base::Vector3d getPoint(int geoId, PointPos pos);

    int diagnose(void);
    bool hasConflicts(void) const { return (Conflicting.size() > 0); };
    const std::vector<int> &getConflicting(void) const { return Conflicting; };

    int setDatum(int constrId, double value);

    int initMove(int geoIndex, PointPos pos);

    int movePoint(int geoIndex, PointPos pos, Base::Vector3d toPoint, bool relative=false);



    int addPoint(const Base::Vector3d &point);
    int addLine(const Part::GeomLineSegment &line);
    int addLineSegment(const Part::GeomLineSegment &lineSegment);
    int addArc(const Part::GeomArcOfCircle &circleSegment);
    int addCircle(const Part::GeomCircle &circle);
    int addEllipse(const Part::GeomEllipse &ellipse);




    int addConstraints(const std::vector<Constraint *> &ConstraintList);
    int addConstraint(const Constraint *constraint);
    int addCoordinateXConstraint(int geoIndex, PointPos pos, double value);
    int addCoordinateYConstraint(int geoIndex, PointPos pos, double value);
    int addDistanceXConstraint(int geoId, double value);
    int addDistanceXConstraint(int geoId1, PointPos pos1, int geoId2, PointPos pos2, double value);
    int addDistanceYConstraint(int geoId, double value);
    int addDistanceYConstraint(int geoId1, PointPos pos1, int geoId2, PointPos pos2, double value);
    int addHorizontalConstraint(int geoIndex);
    int addHorizontalConstraint(int geoIndex1, PointPos pos1, int geoIndex2, PointPos pos2);
    int addVerticalConstraint(int geoIndex);
    int addVerticalConstraint(int geoIndex1, PointPos pos1, int geoIndex2, PointPos pos2);
    int addPointCoincidentConstraint(int geoIndex1, PointPos pos1, int geoIndex2, PointPos pos2);
    int addDistanceConstraint(int geoIndex1, double value);
    int addDistanceConstraint(int geoIndex1, int geoIndex2, double value);
    int addDistanceConstraint(int geoIndex1, PointPos pos1, int geoIndex2, double value);
    int addDistanceConstraint(int geoIndex1, PointPos pos1, int geoIndex2, PointPos pos2, double value);
    int addParallelConstraint(int geoIndex1, int geoIndex2);
    int addPerpendicularConstraint(int geoIndex1, int geoIndex2);
    int addTangentConstraint(int geoIndex1, int geoIndex2);
    int addTangentConstraint(int geoIndex1, PointPos pos1, int geoIndex2);
    int addTangentConstraint(int geoIndex1, PointPos pos1, int geoIndex2, PointPos pos2);
    int addRadiusConstraint(int geoIndex, double value);
    int addAngleConstraint(int geoIndex, double value);
    int addAngleConstraint(int geoIndex1, int geoIndex2, double value);
    int addAngleConstraint(int geoIndex1, PointPos pos1, int geoIndex2, PointPos pos2, double value);
    int addEqualConstraint(int geoIndex1, int geoIndex2);
    int addPointOnObjectConstraint(int geoId1, PointPos pos1, int geoId2);
    int addSymmetricConstraint(int geoId1, PointPos pos1, int geoId2, PointPos pos2, int geoId3);

    enum GeoType {
        None    = 0,
        Point   = 1, // 1 Point(start), 2 Parameters(x,y)
        Line    = 2, // 2 Points(start,end), 4 Parameters(x1,y1,x2,y2)
        Arc     = 3, // 3 Points(start,end,mid), (4)+5 Parameters((x1,y1,x2,y2),x,y,r,a1,a2)
        Circle  = 4, // 1 Point(mid), 3 Parameters(x,y,r)
        Ellipse = 5
    };

    float SolveTime;

protected:
    struct GeoDef {
        GeoDef() : geo(0),type(None),construction(false),index(-1),
                   startPointId(-1),midPointId(-1),endPointId(-1) {}
        Part::Geometry  * geo;             // pointer to the geometry
        GeoType           type;            // type of the geometry
        bool              construction;    // defines if this element is a construction element
        int               index;           // index in the corresponding storage vector (Lines, Arcs, Circles, ...)
        int               startPointId;    // index in Points of the start point of this geometry
        int               midPointId;      // index in Points of the start point of this geometry
        int               endPointId;      // index in Points of the end point of this geometry
    };

    std::vector<GeoDef> Geoms;
    GCS::System GCSsys;
    int ConstraintsCounter;
    std::vector<int> Conflicting;

    // solving parameters
    std::vector<double*> Parameters;    // with memory allocation
    std::vector<double*> FixParameters; // with memory allocation
    std::vector<double> MoveParameters, InitParameters;
    std::vector<GCS::Point>  Points;
    std::vector<GCS::Line>   Lines;
    std::vector<GCS::Arc>    Arcs;
    std::vector<GCS::Circle> Circles;

    bool isInitMove;

private:
    bool updateGeometry(void);

};

} //namespace Part


#endif // SKETCHER_SKETCH_H