ComplexGeoData.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (c) 2002 Jürgen Riegel <juergen.riegel@web.de>              *
 *                                                                         *
 *   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                                *
 *                                                                         *
 ***************************************************************************/
 
 
#pragma once
 
#include <Base/Placement.h>
#include <Base/Persistence.h>
#include <Base/Handle.h>
#include <Base/BoundBox.h>
namespace Core { class CoreDocument; }
 
 
 
namespace Data
{
 
class LX_CORE_EXPORT Segment: public Base::BaseClass
{
    TYPESYSTEM_HEADER();
 
public:
    virtual ~Segment(){}
    virtual std::string getName() const=0;
};
 
 
class LX_CORE_EXPORT ComplexGeoData: public Base::Persistence, public Base::Handled
{
    TYPESYSTEM_HEADER();
 
public:
    struct Line  {uint32_t I1; uint32_t I2;};
    struct Facet {uint32_t I1; uint32_t I2; uint32_t I3;};
    struct Domain {
        std::vector<Base::Vector3d> points;
        std::vector<Facet> facets;
    };
 
    ComplexGeoData(void);
 
    virtual std::vector<const char*> getElementTypes(void) const=0;
    virtual unsigned long countSubElements(const char* Type) const=0;
    virtual Segment* getSubElement(const char* Type, unsigned long) const=0;
    virtual Segment* getSubElementByName(const char* Name) const;
    virtual void getLinesFromSubelement(
        const Segment*,
        std::vector<Base::Vector3d> &Points,
        std::vector<Line> &lines) const;
    virtual void getFacesFromSubelement(
        const Segment*,
        std::vector<Base::Vector3d> &Points,
        std::vector<Base::Vector3d> &PointNormals,
        std::vector<Facet> &faces) const;
 
    void applyTransform(const Base::Matrix4D& rclTrf);
    void applyTranslation(const Base::Vector3d&);
    void applyRotation(const Base::Rotation&);
    void setPlacement(const Base::Placement& rclPlacement);
    Base::Placement getPlacement() const;
    virtual void setTransform(const Base::Matrix4D& rclTrf)=0;
    virtual Base::Matrix4D getTransform(void) const = 0;
 
    virtual void transformGeometry(const Base::Matrix4D &rclMat) = 0;
 
    virtual Base::BoundBox3d getBoundBox(void)const=0;
    virtual Base::Vector3d getPointFromLineIntersection(
        const Base::Vector3f& base,
        const Base::Vector3f& dir) const;
    virtual void getPoints(std::vector<Base::Vector3d> &Points,
        std::vector<Base::Vector3d> &Normals,
        float Accuracy, uint16_t flags=0) const;
    virtual void getLines(std::vector<Base::Vector3d> &Points,std::vector<Line> &lines,
        float Accuracy, uint16_t flags=0) const;
    virtual void getFaces(std::vector<Base::Vector3d> &Points,std::vector<Facet> &faces,
        float Accuracy, uint16_t flags=0) const;
    virtual bool getCenterOfGravity(Base::Vector3d& center) const;
 
    static const std::string &elementMapPrefix();
    static const std::string &tagPostfix();
    static const std::string &indexPostfix();
    static const std::string &missingPrefix();
    static bool hasMissingElement(const char *subname);
    static const char *isMappedElement(const char *name);
 
    static std::string newElementName(const char *name);
    static std::string oldElementName(const char *name);
    static std::string noElementName(const char *name);
 
    static const char *findElementName(const char *subname);
 
    static inline const char *hasMappedElementName(const char *subname) {
        return isMappedElement(findElementName(subname));
    }
 
protected:
 
    inline Base::Vector3d transformToOutside(const Base::Vector3f& vec) const
    {
        return getTransform() * Base::Vector3d(vec.x,vec.y,vec.z);
    }
    inline Base::Vector3f transformToInside(const Base::Vector3d& vec) const
    {
        Base::Matrix4D tmpM(getTransform());
        tmpM.inverse();
        Base::Vector3d tmp = tmpM * vec;
        return Base::Vector3f((float)tmp.x,(float)tmp.y,(float)tmp.z);
    }
public:
    mutable long Tag;
};
 
} //namespace App