SPoly.h

 
 
 
 
#pragma once
 
#include "RshPluginScript/RshPluginScriptDefines.h"
#include "RshGeometry/Texture/RshTextureMap.h"
#include "RshPluginScript/SClass/SComp.h"
 
#ifndef FCT_DOC
namespace rsh::ScriptBinding
{
#endif // !FCT_DOC
 
class SPoly : public SComp
{
    //======================================================================================================================
    //                                       INTERNAL FUNCTION
    //======================================================================================================================
 
    //======================================================================================================================
    //                                      DOCUMENTED FUNCTION
    //======================================================================================================================
public:
    enum PolyRepresentationTypeEnum
    {
        // representations which are always available
        POLY_SMOOTH, // flat shading and compatible with real time edition
        POLY_FLAT, // segments and vertices are displayed
        POLY_WIRE, // wireframe
        POLY_SMOOTH_WIRE, // smooth shading et wireframe together
        POLY_FLAT_WIRE, // flat shading and wireframe together
        POLY_SMOOTH_REALTIME, // smooth shading and compatible with real time edition
        POLY_TEXTURE, // Textured points / Vertex
        POLY_COLORED, // Colored points / Vertex
        POLY_INSPECTION, // Calculate a color based on a value on each vertex.
        POLY_FLAT_TEXTURE_COLOR, // representation with one color per texture
        POLY_TEXTURE_ASYNC,
    };
 
 
    enum SmoothEnum
    {
        //      NORMAL_SMOOTH// The normal smoothing
        //      , DEV_CTRL_SMOOTH// The deviation control smoothing
        POLY_SMOOTH_KEEP_DETAILS, // Try to keep details during smoothing.
        POLY_SMOOTH_LIMIT_DIST_BY_PROJ, // We limit the distance of the new vertex location against
        //      the projection on the original surface. Otherwise we limit distance against the original vertex location.
        POLY_SMOOTH_COMPLEX_SURF, // We consider original mesh triangles as complex surfaces to compute the distance
        //      distance of the new vertex location. Otherwise we consider mesh triangles as flat
        POLY_SMOOTH_SMOOTH_BORDERS, // If free borders can move
    };
 
    enum OffsetEnum
    {
        NORMAL_OFFSET, // The basic offset
        NO_AUTO_INTERSECTION// Auto-intersection are removed in the zones where
        // the offset value is greater than the local radius
    };
 
    enum BordersEnum
    {
        NO_CHANGE, // Don't change free edges (borders)
        REFINE, // Refine free edges
        EXTEND_REFINE// Extend (if some cloud points are outside free borders) and refine free edges.
    };
 
    enum DeviationOptionEnum
    {
        KEEP_EQUI, // Re-mesh locally to preserve equilateral triangles if it is possible.
        BEST_POS, // Allows to move the point to another position in order to keep the mesh aspect (create new vertices).
        ON_BORDERS// Allows to also reduce the free borders (will reduce free borders size and can result in filling some small holes).
    };
 
    enum ProjectionTypeEnum
    {
        PERSPECTIVE, // Standard pinhole camera model
        EQUIRECTANGULAR, // Spherical camera, with equirectangular image projection
        REPETITIVE, // To map a repetitive texture
        FISH_EYE, // Fish Eye image projection
    };
 
    enum SphereEnum
    {
        SPHERE_FORCE_NOTHING, // Nothing is forced
        SPHERE_FORCE_RADIUS, // Radius is forced
        SPHERE_FORCE_CENTER// Center is forced
    };
 
    enum CylinderEnum
    {
        CYL_FORCE_NOTHING, // Nothing is forced
        CYL_FORCE_RADIUS, // Radius is forced
        CYL_INIT_RADIUS, // Radius is initialized (near from its good value)
        CYL_FORCE_CENTER, // Center is forced (an axis passing through Center should be found)
        CYL_INIT_CENTER, // Center is initialized (near from its good position)
        CYL_FORCE_DIRECTION, // Direction is forced (DirectionVector exactly)
        CYL_INIT_DIRECTION// Direction is approximately (DirectionVector nearly)
    };
 
    enum StitchOverlapEnum
    {
        STITCHOVERLAP_MAKE_SEWING_ZONE_INVISIBLE, // Modify the sewing zone so that it should not be visible.
        STITCHOVERLAP_REORGANIZE_SEWING_ZONE, // Reorganize the sewing zone.
        STITCHOVERLAP_MODIFY_OVERLAP_IN_MIDDLE_ZONE, // Modify the output overlapping surface so that it becomes in the middle of the two input surfaces.
        STITCHOVERLAP_ONLY_CONSISTENT_NORMALES, // Process only overlapping areas having triangle normals oriented in the same way. Do not change triangle orientation during the stitching.
    };
 
    enum SeparateTriBoxEnum
    {
        SEPARATETRIBOX_STRICLTY_INSIDE, // Select triangles that are strictly inside the box
        SEPARATETRIBOX_ONLY_CROSSING, // Select triangles that are only crossing the box
        SEPARATETRIBOX_CROSSING_AND_INSIDE, // Select triangles that are crossing the box or inside
    };
 
    enum SeparateTriBoxSelectEnum
    {
        SEPARATETRIBOX_KEEP_INSIDE_TRI, //Update the current SPoly and keep only triangles inside the box (or only triangles crossing the box).
        SEPARATETRIBOX_KEEP_OUTSIDE_TRI, //Update the current SPoly and  Keep only unselected triangles
        SEPARATETRIBOX_KEEP_BOTH, // Keep both parts, the current SPoly will be made with unselected triangles, the selected triangles will be put inside  Array.Poly
    };
 
    enum SegmentationFeaturesEnum
    {
        SEGMENTATION_PLANE, // Extract planes in the mesh segmentation.
        SEGMENTATION_SPHERE, // Extract spheres in the mesh segmentation
        SEGMENTATION_CONE, // Extract cones in the mesh segmentation
        SEGMENTATION_CYLINDER, // Extract cylinders in the mesh segmentation
        SEGMENTATION_All// Extract all available features in the mesh segmentation
    };
 
public slots: // these functions (slots) will be available in QtScript
 
 
    // TESTED
      Clear() ;
 
    // TESTED
    Array GetSurface();
 
    // TESTED
    Array GetVolume(
        Boolean iIsOnlyIfClosed
    );
 
    // TESTED
    Number GetNbPieces();
 
    // TESTED
    Array GetInertiaMatrix(
        Boolean iIsOnlyIfClosed
    );
 
    // TESTED
    Array SectionPlane(
         SVector iPlaneNormal, 
        SPoint iPtFirstPlane, 
        Number iNbPlanes, 
        Number iDistance 
    );
 
    // TESTED
    Array SectionRadial(
        SPoint iFirstPointOnAxis, 
        SPoint iSecondPointOnAxis, 
        SPoint iPtFirstPlane, 
        Number iNbSections, 
        Number iMaxAngleInRadian 
    );
 
    // TESTED
    Array SectionCylindric(
        SPoint iFirstPointOnAxis, 
        SPoint iSecondPointOnAxis, 
        SPoint iPointOnTheFirstCylinder, 
        Number iNumberOfCylinders, 
        Number iDistanceBeetweenCylinders 
    );
 
    //TESTED
    Array SectionOnMultiReg(
        SMultiline iMultiLine, 
        Number iDist, 
        Number iMaxDist, 
        Number iOptBitMask
    );
    //TESTED
    Array SectionOnMulti(
        SMultiline iMultiLine, 
         Array<Number> iListDist, 
        Number iMaxDist, 
        Number iOptBitMask
    );
 
    // TESTED
    Array InterInfLine(
        SPoint iPoint, 
        SVector iVect 
    ) ;
 
    // TESTED
    Array Proj3D(SPoint iPoint 
    ) ;
 
    // TESTED
    Array Proj3D(
        SMultiline iMultilineToProject, 
        Boolean iHadIntermediatePt
    ) ;
 
    // TESTED
    Array ProjDir(
        SPoint iPoint, 
         SVector iDirection, 
        Boolean iIsSignedProjection
    ) ;
 
    // TESTED
    Array ProjDir(
        SMultiline iMultilineToProject, 
         SVector iDirection, 
        Boolean iHadIntermediatePt, 
        Boolean iIsSignedProjection
    ) ;
 
    // TESTED
    Array Explode() ;
 
    Array ExplodeColor() ;
 
    Array ExplodeWithInspectionSteps() ;
 
    Array SeparateTriangleSize(
        Number iSmallestSize, 
        Number iBiggestSize 
    ) ;
 
    Array SeparateTriangleBox(
        SPoint iLowerPoint, 
        SPoint iUpperPoint, 
        SeparateTriBoxEnum iSelType, 
        SeparateTriBoxSelectEnum iWhichPartToKeep 
    );
 
 
    Array SeparateTriangleInPrism(
        SMultiline iProfil, 
        Number iDistance, 
        SeparateTriBoxEnum iSelType, 
        SeparateTriBoxSelectEnum iWhichPartToKeep 
    );
 
    Array SeparateTriangleWithActivatedClippingPlanes(
         Array<SClippingPlane>
            iClippingPlanes, 
        SeparateTriBoxEnum iSelType 
    );
 
    Array GetTriangleSize() ;
 
    // TESTED
    Array BooleanAdd(SPoly iPoly);
 
    // TESTED
    Array BooleanSub(SPoly iPoly);
 
    // TESTED
    Array BooleanCommon(SPoly iPoly 
    );
 
    // TESTED
    Array BooleanCutIn(SPoly iPoly 
    );
 
    // TESTED
    Array BooleanCutOut(SPoly iPoly 
    );
 
    Array BooleanOperation(
        SPoly iPoly, 
        Boolean iIsCutPoly
    );
 
    // TESTED
    Array Intersect(
        SPoly iPoly, 
        Number iOption 
    );
 
    // TESTED
    Array Smooth(
        Number iLoopNumber, 
        SmoothEnum iOptionMask, 
        Number iMaxiDeviation, 
        Boolean iIsReorganise, 
        Number iMinAngleReorg, 
        Number iRefineDistProj = -1.0, 
        Number iRefineVrtxAngle =
            -1.0, 
        Number iAngleSharpEdge = -1.0, 
        Number iNbTriMax =
            -1 
    );
 
    //TESTED
    Array Offset(
        Boolean iIsDirect, 
        Number iDistCoef, 
        OffsetEnum iOptBitMask
    ) ;
 
    // TESTED
    Array RemeshRefineDev(
        Number iDeviation, 
        Number iSizeMin, 
        Number iMaxiTriNumber, 
        BordersEnum iBorderOption, 
        Number iDistanceWrongPoints, 
        Number iReorganize, 
        SCloud iCloud, 
        Number iMaxCosAngle = -1 
    ) ;
 
    // TESTED
    Array Reduce(
        Number iTargetNbVertex, 
        Number iMinAngle 
    );
 
    // TESTED
    Array Compare(
        SPoly iMeasPoly, 
        Number iDistMax, 
        Number iMappingObject, 
        Boolean iIsIgnoreEdge, 
        SVector iDirection, 
        Number iMaxCosAngle = 0., 
        Boolean iIsCheckThinParts
    );
 
    // TESTED
    Array Compare(
        SCloud iMeasCloud, 
        Number iDistMax, 
        Number iMappingObject, 
        Boolean iIsIgnoreEdge, 
        SVector iDirection, 
        Number iMaxCosAngle = -2, 
        Boolean iIsCheckForThinParts
    );
 
    Number GetNumberOfTextureMaps() ;
 
    Array GetNumberOfTextures() ;
 
    Array GetTextureName(Number iTextureIdx 
    ) ;
 
    Array RemoveTexture();
 
    // TESTED
    Array ReduceDeviation(
        Number iDeviationError, 
        DeviationOptionEnum iCriteria, 
        Boolean iIsKeepSharpEdge, 
        Number iDeviationOnSharpEdges, 
        Number iSharpEdgeAngleValue, 
        Number iMaxEdgeLength, // [in] /// The maximum length of the new edges. Use to avoid having too big triangle.
        Number iDeviationOnBorders
    );
 
    Array Contours(Boolean iIsExportSuspiciousTriangles = false);
 
    Array FillHoles(
         Array<SPoint> iPointTable, 
        Number iTension, 
        Number iWallThickness = -1 
    );
 
    Array FillContours(
         Array<SMultiline> iContourTable, 
        Number iTension = 0.732f, 
        Number iWallThickness = -1, 
        Boolean iIsForceNonSmoothShape
    );
 
    // TESTED
    Array FillHolesDirection(
         SVector iDirection, 
         Array<SPoint> iPointTable, 
        Number iTension
    );
 
    Array SmoothBorders(
         Array<SPoint> iPointTable, 
        Number iMaxEdgeLength
    );
 
    Array SetBorders(
         Array<SMultiline> iMultiTbl, 
        Number iRemeshDistance 
    );
 
    Array ImproveBorders(
         Array<SSetMultiline> iSetMultiTbl, 
        Number iRemeshDistance, 
        Number iCleaningDistance 
    );
 
    Array Save(
        String iFilePath, 
        Boolean iIsTextExport, 
        SMatrix iCoordinateSystemMatrix = {}
    );
 
    Array GetColorGradient() { return SComp::GetColorGradient(); }
 
    Array LoadColorGradient(String iFilePath 
    )
    {
        return SComp::LoadColorGradient(iFilePath);
    }
 
    Array SaveColorGradient(String iFilePath 
    )
    {
        return SComp::SaveColorGradient(iFilePath);
    }
 
    //TESTED
    Array ExtractPlane(
        SPoint iSeedPoint, 
        Number iTolerance 
    ) ;
 
    Array ExtractSphere(
         Array<SPoint>
            iSeedPoint, 
        Number iTolerance, 
        SphereEnum iForce, 
        SPoint Center = {}, 
        Number iRadius
    );
 
    Array ExtractCylinder(
         Array<SPoint>
            iSeedPoint, 
        Number iTolerance, 
        CylinderEnum iForce, 
        SPoint iCenter = {}, 
         SVector iDirectionVector = {}, 
        Number iRadius
    );
 
    Array ExtractFeatureLines(
        Number iSmoothingIntensity = 0.0 
    );
 
    Array GetContours() ;
 
    Number GetTrianglesNumber() ;
 
    Array RemoveSpikes(
        Number iLoopNumber, 
        Number iPropag = -1, 
        Number iIntensity, 
        Boolean iIsRecalculateBorder
    );
 
    Array Tolerance3DMesh(
        SCloud iCloud, 
         Number iDeviation, 
         Number iDistanceWrongPoints, 
         Number iSizeTriMax, 
        Boolean iIsReorganize, 
        Number iExtension, 
        Boolean iIsNoiseReduct 
    );
 
    Array ConstraintMesh3D(
        SCloud iCloudOfPoints, 
         Array<SMultiline>
            iSetOfMultilines, 
        Number iTolerance, 
        Number iZoneType 
    ) ;
 
    Array GetSilhouette(
         SVector iViewDirection, 
        Number iDraftAngle, 
        Number iMinClosedLine, 
        Number iMinUnclosedLine, 
        Number iResultType 
    ) ;
 
    Array TextureAddRepetitive(
         String iFilePathName, 
        Number iNbRepWidth, 
        Number iNbRepHeight, 
         SVector iDirXScreen, 
         SVector iDirYScreen, 
        SPoint iImageOrigin 
    );
 
    Array RemeshSharpEdge(
         Array<SMultiline>
            iLines, 
        SPoint iReferencePoint 
    );
 
    Array TakeColorFromClouds(
         Array<SCloud> iCloudsTbl, 
        Number iIgnoreOver, 
        Number iResetColor, 
        Number iDefaultRed, 
        Number iDefaultGreen, 
        Number iDefaultBlue 
    );
 
     SetPolyRepresentation(PolyRepresentationTypeEnum Representation 
    );
 
    Array LocalizeValues( Array<Number> iThresholdList 
    );
 
    Array WriteOnMesh(
         String iTextToWrite, 
         SVector iTextNormal, 
         SVector iTextHorizontalNormal, 
        SPoint iTextPosition, 
        Number iTextDepth, 
        Number iPlaneDepth, 
        Number iScale, 
         String iFont = "Arial", 
        Boolean isBold, 
        Boolean isItalic, 
        Number iWritingStyle
    );
 
    Array GetHighestPoint(
         SVector iDirection 
    ) ;
 
    Array GetLowestPoint(
         SVector iDirection 
    ) ;
 
    Array Cubature(
        SPoly iSecondPoly, 
        SVector iProjDir = {} 
    );
 
    Array DestructTrianglesOnHoles(
        SCloud iCloud, 
        Number iHoleSize, 
        Number iMaxDistToCloud = 0.f, 
        Number iOptions, 
        Number iMaxCosAngle = -1 
    );
 
    Array RemoveTrianglesOnHoles(
        SCloud iCloud, 
        Number iHoleSize, 
        Number iMaxDistToCloud =
            -1, 
        Number iMaxAngle = -1 
    );
 
    Array StitchOverlap(
        SPoly iMeshToStitch, 
        Number iTolDist, 
        StitchOverlapEnum iOptions 
    );
 
    Array VolumeFromElevation(
         Array<Number> iElevations, 
         SVector iProjDir = { 0., 0., 1. } 
    );
 
    Array SubdivideTriangles(
         Number iMaxEdgeLength, 
         Boolean iIgnoreFreeEdges, 
         Number iLimitCos = 0., 
         Boolean iPreserveGeometry
    );
 
    Array MeshSegmentation(
        Number iAngleThreshold = 15.0, 
        Number iMergeMaxDistance = 0., 
        Number iMinRegionArea = 0., 
        Number iClassificationMaxDistance = 0., 
        SegmentationFeaturesEnum iFeatures
    ) ;
 
    String toString() ;
};
 
// @brief
// this class allow to wrap static function to SPoly easily
// this allow to wrap constructor more easily the constructor will be declared with the function New(...)
class SPoly
#ifndef FCT_DOC
    : public SObjectStatic
#endif // FCT_DOC
{
    //======================================================================================================================
    //                                       INTERNAL FUNCTION
    //======================================================================================================================
 
    //======================================================================================================================
    //                                      DOCUMENTED FUNCTION
    //======================================================================================================================
public:
    enum HoleOptionEnum
    {
        NO_CLOSED,
        INSIDE_CLOSED,
        ALL_CLOSED};
 
    enum FusionOptionEnum
    {
        SIMPLE, // Simple fusion without any modification
        REMESH, // If parallel free contour are found try to re-mesh locally to merge them.
        FILL_HOLES, // Try to fill all the holes except the biggest one (free border).
        CLOSE// Try to close the polyhedron
    };
 
    enum RotateEnum
    {
        ROTATE_AUTO, // Function will defined automatically the good rotate point
        ROTATE_CENTROID, // Use centroid of the profile
        ROTATE_INTERSECTION, // Use intersection of the profile with path
        ROTATE_USER_DEFINE // You must defined your rotate point
    };
 
public slots:
    // TESTED
    static SPoly New();
 
    // TESTED
    static SPoly New(SPoly iOther);
 
    static Array ColorAlongDir(
         Array<SPoly> iMeshes, 
         SVector iDirectionVect, 
        SPoint iOrigin = {} 
    );
 
    static Array FromClick() { return SComp::GetFromClick<SPoly>(SV_POLY); }
 
    static Array FromName( String iName) { return SComp::GetFromName<SPoly>(iName); }
 
    // TESTED
    static Array FromSel();
 
    // TESTED
    static Array All(
        Number iVisCrit
    )
    {
        return SComp::GetAll<SPoly>(iVisCrit);
    }
 
    // TESTED
    static Array FromFile(String iFileName 
    );
 
    static Array ConstraintMesh2D(
        SCloud iCloudOfPoints, 
        Array<SMultiline>
            iSetOfMultilines, 
        SVector iMeshDir, 
        Number iTolerance, 
        Number iZoneType 
    );
 
    // TESTED
    static Array Direct3DMesh(
        SCloud iCloudToMesh, 
        Number iDeviationError, 
        Number iMiniAverageDist, 
        HoleOptionEnum iOptionHole, 
        Number iSizeTriHole, 
        Boolean iIsIgnoreScanDir
    );
 
    // TESTED
    static Array DirectionMesh(
        SCloud iCloudOfPoints, 
         SVector iMeshingDirection, 
        Number iTolerance, 
        Boolean iIsFindCntr
    );
 
    static Array SphericalMesh(
         Array<SCloud> iCloudOfPoints, 
        SPoint iScanPos, 
        Number iRegularSampling, 
        Number iDeviationErr, 
        Number iMaxiNbTriangle, 
        Number iAlphaShapeThreshold, 
        Number iMaxSizeThreshold, 
        Number iMinSizeThreshold, 
        Number iDeleteSmall 
    );
 
    static Array Extrusion(
        SMultiline iProfile, 
        SMultiline iPath, 
        Boolean iTurnWithPath, 
        Boolean iPerpendicularToPath, 
        SMultiline iSecondPath, 
        RotateEnum iOption, 
        // ROTATE_AUTO // Function will defined automatically the good rotate point
        // ROTATE_INTERSECTION // Use intersection of the profile with path
        SPoint iRotatePt
    );
 
    // TESTED
    static Array Fusion(
         Array<SPoly> iPolyTable, 
        FusionOptionEnum iOption, 
        Number iAccuracyPoint = 1.E-5, 
        Number iAccuracyBorders = 0.001 
    );
 
    static Array MergeCommonBorders(
         Array<SPoly> iPolyTable, 
        FusionOptionEnum iOption, 
        Number iAccuracyPoint = 1.E-5, 
        Number iAccuracyBorders = 0.001 
    );
 
    // TESTED
    static Array JoinContour(
         Array<SMultiline>
            iMultiLines, 
         Array<SPoly>
            iPolyhedrons, 
        Number iTangency1, 
        Number iTangency2, 
        Number iTension = 0.732, 
        Boolean iReorganize, 
        Number iNbPoint
    );
 
    static Array CreateCompound(
         Array<SPoly> iTablePoly, 
        Boolean iOptOrient
    );
 
    static Array PipeTubeAlongPath(
         Number iRadius,
         Boolean iCloseExtremities,
         Array<SComp> iComps);
 
    static Array LinearExtrusion(
        Number iLength,
         SVector iDirection,
        Boolean iCloseExtremities,
         Array<SComp> iComps);
 
    static String toString();
};
Q_DECLARE_METATYPE(SPoly::_SPolyDummy);
Q_DECLARE_METATYPE(SPoly);
 
#ifndef FCT_DOC
} // namespace rsh::ScriptBinding
#endif // !FCT_DOC
 
#ifndef FCT_DOC
namespace rsh::Script::ScriptConvert
{
template<>
struct TblConvert<SPoly>
{
    static  char GetClassName() { return "SPoly"; }
 
    typedef SPoly ScriptClass;
    typedef SPoly DCompClass;
 
    static SPoly GetGCompClass(SPoly _iCompClass)
    {
        return _iCompClass.GetGPoly();
    }
 
    static SPoly ForDCompConstructor(SPoly _iEnt) { return _iEnt; }
};
#endif
}