SCloud.h

 
 
 
 
#pragma once
 
#include "RshPluginScript/RshPluginScriptDefines.h"
#include "RshPluginScript/SClass/SCloudIterCPP.h"
#include "RshPluginScript/SClass/SComp.h"
 
#ifndef FCT_DOC
namespace rsh::ScriptBinding
{
#endif // !FCT_DOC
 
class SCloud : public SComp
{
    //======================================================================================================================
    //                                       INTERNAL FUNCTION
    //======================================================================================================================
 
    //======================================================================================================================
    //                                      DOCUMENTED FUNCTION
    //======================================================================================================================
 
public:
    enum CloudRepresentationTypeEnum
    {
        // representations which are always available
        CLOUD_FLAT, // flat - no shading
        CLOUD_SMOOTH, // smooth shading
        CLOUD_SMOOTH_BACK, // smooth shading + back and front in different color (only available if scanning direction is known)
 
        CLOUD_COLORED, // Colored points (only available if the cloud contains color information)
        CLOUD_INSPECTION, // Colors ares based on an inspection value on each point. (only available if the cloud contains inspection information)
        CLOUD_CLASSIFICATION, // Colors ares based on classification ID on each point. (only available if the cloud contains classification information)
        CLOUD_DEBUG_SPLATTING_SMOOTH, // Displays the cloud using the splatting method (For debug only)
        CLOUD_DEBUG_SPLATTING_COLORED, // Displays the cloud using the splatting method using colored points (only available if the cloud contains color information) (For debug only)
    };
 
 
    enum MethodBestSqSlotEnum
    {
        BEST_SQ_SLOT};
 
    enum BestRectangleForce
    {
        NO_FORCE, 
        FORCE_NORMAL, 
        FORCE_PLANE, 
        FORCE_MAIN_DIRECTION, 
        FORCE_LENGTH, 
        FORCE_WIDTH, 
        FORCE_SQUARE, 
        FORCE_IN_BEST_PLANE, 
        FORCE_CENTER, 
    };
 
    enum FillCloudEnum
    {
        FILL_ALL, // Both InCloud and OutCloud should be filled
        FILL_IN_ONLY, // Only Fills the InCloud
        FILL_OUT_ONLY, // Only Fills the OutCloud
        FILL_NONE// Neither InCloud nor OutCloud should be filled
    };
 
    enum PlaneEnum
    {
        PLANE_FORCE_NOTHING, // Nothing is forced
        PLANE_FORCE_POINT, // Average point is forced (a plane passing by this point should be found)
        PLANE_FORCE_NORMAL// Normal is forced (a plane with this normal should be found)
    };
 
    enum LineEnum
    {
        LINE_FORCE_NOTHING, // Nothing is forced
        LINE_FORCE_POINT, // Average point is forced (a line passing by this point should be found)
        LINE_FORCE_DIRECTION// Line direction is forced (a line with this direction should be found)
    };
 
    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 CircleEnum
    {
        CIRCLE_FORCE_NOTHING,
        CIRCLE_FORCE_RADIUS, // Radius is forced (using the value of the current circle)
        CIRCLE_FORCE_CENTER, // Center is forced (using the value of the current circle)
        CIRCLE_FORCE_NORMAL// Normal vector is forced (using the value of the current circle)
    };
 
    enum MethodBestCircleEnum
    {
        BEST_CIRCLE, // Best element extracted from the cloud
        BEST_CIRCULARITY, // Circularity element extracted from the cloud
    };
 
    enum MeshingMode
    {
        LOW,
        MEDIUM,
        HIGH};
 
#ifndef FCT_DOC
    enum TunnelExtractionStrategyEnum
    {
        TUNNEL_APPROXIMATION,
        TUNNEL_QUICK_EXTRACTION,
        TUNNEL_DENSE_EXTRACTION};
#endif 
public slots: // these functions (slots) will be available in QtScript
 
 
    // TESTED
      Clear() ;
 
    // TESTED
    Array Chain(Number ChainingDist 
    ) ;
 
    // TESTED
     AddPoint(SPoint PointToAdd 
    );
 
    // TESTED
    Number GetNumber() ;
 
    // TESTED
    Array Explode(
        Number MaxDistance, 
        Number DelNb, 
        Number MaxNb
    ) ;
 
    //TESTED
    Array Separate(
        SMultiline iClosedContour, 
         SVector Direction, 
        SPoint PntFirstPlane, 
        SPoint PntSecondPlane, 
        FillCloudEnum fillCloud
    );
 
    //TESTED
    Array BestPlane(
        Number NbPointElim, 
        PlaneEnum Force, 
        SPoint iPtToForce = {}, 
         SVector DirectionToForce = {}, 
        FillCloudEnum fillCloud
    ) ;
 
    //TESTED
    Array ExtractPlane(
         Array<SPoint>
            SeedPoint, 
        Number Tolerance, 
        PlaneEnum Force, 
        SPoint iAveragePoint = {}, 
         SVector DirectionVector = {}, 
        FillCloudEnum fillCloud
    ) ;
 
    //TESTED
    Array BestCircle(
        MethodBestCircleEnum Method, 
        Number NbPointElim, 
        CircleEnum Force, 
        SPoint iCenter = {}, 
         SVector Normal = {}, 
        Number Radius, 
        FillCloudEnum fillCloud
    ) ;
 
    //TESTED
    Array BestCylinder(
        Number NbPointElim, 
        CylinderEnum Force, 
        SPoint iCenter = {}, 
         SVector DirectionVector = {}, 
        Number Radius, 
        FillCloudEnum fillCloud
    ) ;
 
    Array ExtractCylinder(
         Array<SPoint>
            SeedPoint, 
        Number Tolerance, 
        CylinderEnum Force, 
        SPoint iCenter = {}, 
         SVector DirectionVector = {}, 
        Number Radius, 
        FillCloudEnum fillCloud
    );
 
    Array BestSphere(
        Number NbPointElim, 
        SphereEnum Force, 
        SPoint iCenter = {}, 
        Number Radius, 
        FillCloudEnum fillCloud
    ) ;
 
    Array ExtractSphere(
         Array<SPoint>
            SeedPoint, 
        Number Tolerance, 
        SphereEnum Force, 
        SPoint iCenter = {}, 
        Number Radius, 
        FillCloudEnum fillCloud
    );
 
    Array ExtractMedianPointOnWhiteLine(
        SPoint iSeedPoint,
         Number iSphereRadius,
         Number iOptionMask,
         FillCloudEnum iFillCloud = FILL_NONE) ;
 
    Array BestCone(
        FillCloudEnum fillCloud, 
        Number nbPointsElim
    ) ;
 
    Array RegionGrowFreePolyline(SPoint iSeedPoint, Number iSamplingStep) ;
 
    Array BestLine(
        Number NbPointElim, 
        LineEnum Force, 
        SPoint iAveragePoint = {}, 
         SVector DirectionVector = {}, 
        FillCloudEnum fillCloud
    ) ;
 
    Array BestSqSlot(
        MethodBestSqSlotEnum method, 
        Number NbPointElim, 
        BestRectangleForce Force, 
        SPoint iCenter = {}, 
         SVector Normal = {}, 
         SVector MainDirection = {}, 
        Number Length, 
        Number Width, 
        FillCloudEnum fillCloud
    ) ;
 
    Array CleanFeatureOrientation(
        SComp FeatureType, 
        Number Angle, 
        Number DistanceTolerance, 
        Boolean useEstimatedDirection, 
        FillCloudEnum fillCloud
    );
 
    Array CleanWithLocalNormal(
        Number Angle, 
        FillCloudEnum FillCloud
    );
 
    Array CleanPolyOrientation(
        SPoly Polyhedron, 
        Number Angle, 
        Number DistanceTolerance, 
        Boolean useEstimatedDirection, 
        Boolean checkForThinParts, 
        FillCloudEnum fillCloud
    );
    //TESTED
    Array SeparateFeature(
        SComp FeatureType, 
        Number Tolerance, 
        FillCloudEnum fillCloud
    );
    //TESTED
    Array SeparateMultiline(
         SMultiline Multiline, 
        Number Tolerance, 
        FillCloudEnum fillCloud
    );
 
    Array SeparatePoly(
        SPoly Polyhedron, 
        Number Tolerance, 
        FillCloudEnum fillCloud
    );
 
    // This list is sorted by number of points with the biggest
    // first.
    //TESTED
    Array ExplodeColor() ;
 
    Array ExplodeWithInspectionSteps() ;
 
    // TESTED
    Array NoiseReductionSplit(Number Threshold 
    );
 
    // TESTED
    Array Reduce(Number NumberOfPoints 
    ) ;
 
    // TESTED
    Array ReduceBest(
        Number MiniAverageDist, 
        Number MaxAverageDist 
    ) ;
 
    Array SectionPlane(
         SVector NormalVectorOfThePlanes, 
        SPoint iPointOnTheFirstPlane, 
        Number NumberOfParallelPlanes, 
        Number DistanceBeetweenParallelPlanes, 
        Number PlaneThickness, 
        Number ChainingDist, 
        Boolean NoiseReduction 
    ) ;
 
    Boolean hasScanDir() ;
 
    // TESTED
    Array Save(
        String FilePath, 
         QChar decimalSeparator = '.', 
        Boolean EXPORT_SCAN_DIR, 
        SMatrix CoordinateSystemMatrix = {}
    );
 
    Array ClosestPoint(
        SPoint iInputPt, 
        SPoint CenterPt, 
        Number Distance
    ) ;
 
    Array ProjDir(
        SPoint iPointToProject, 
         SVector Direction, 
        Number Aperture, 
        Boolean DirectionUnsigned
    ) ;
 
    Array ProjectOnPlane(SPlane iPlane 
    ) ;
 
    SCloudIterator GetIterator();
 
    Array GetColorGradient() { return SComp::GetColorGradient(); }
 
    Array LoadColorGradient(String FilePath 
    )
    {
        return SComp::LoadColorGradient(FilePath);
    }
 
    Array SaveColorGradient(String FilePath 
    )
    {
        return SComp::SaveColorGradient(FilePath);
    }
 
    Array GetCentroid();
 
    Array GetHighestPoint(
         SVector Direction 
    ) ;
 
    Array GetLowestPoint(
         SVector Direction 
    ) ;
 
    Array GetConvexContour(
        SVector ViewDirection, 
        SPoint PointOnPlane, 
        Boolean Is3dContour
    ) ;
 
    Array GetConvexHull() ;
 
#ifndef FCT_DOC
    Array ExtractTunnel(
        SMultiline iNeutralAxis,
        Number Step,
        TunnelExtractionStrategyEnum ExtractionStrategy,
        SCloud iCoarseCloud = nullptr) ;
#endif // FCT_DOC
 
     SetCloudRepresentation(CloudRepresentationTypeEnum Representation 
    );
 
    CloudRepresentationTypeEnum GetCloudRepresentation();
 
    Array Compare(
        SCloud MeasuredCloud, 
        Number DistMax, 
        SVector Direction, 
        Boolean checkBothDirection, 
        Number maxCosAngle = -2, 
        Boolean checkNormals
    );
 
     SetPointSize(Number pointSize 
    );
 
    Number GetPointSize();
 
    Number HasColor();
 
    Number HasInspection();
 
    Number HasGriddedInformation();
 
    Array FlipIntensities();
 
    Array ConvertInspectionToColor();
 
    Array LocalizeValues(
        Number iMin, 
        Number iMax 
    );
 
    Array ComputeFlatAndCurvedAreas(Number iNeighborhoodRadius = 0.0, Number iOptionMask = 0);
 
    Array GetScanningPositions();
 
    Array FilterMovingObjects(Number iResolutionAt10m, Number iThreshold);
 
    Array FilterByNormalDirection( SVector iDirection, Number iMinCosAngle, Boolean isDirectionSigned);
 
    Number GetMeanDistance() ;
 
    Array ExtractMultilineFromSeed(
        SPoint iSeedPoint,
         Number iTolerance,
         Number iCylinderLength,
         Number iSearchRange,
        Boolean iChainOption);
 
    Array ExplodeByClass();
 
    String toString() ;
 
    Array ScanToMesh(MeshingMode iMeshingMode, Boolean iTextureFromCloud, Boolean iIgnoreScanDir);
};
 
// @brief
// this class allow to wrap static function to SCloud easily
// this allow to wrap constructor more easily the constructor will be declared with the function New(...)
class SCloud
#ifndef FCT_DOC
    : public SObjectStatic
#endif // FCT_DOC
{
    //======================================================================================================================
    //                                       INTERNAL FUNCTION
    //======================================================================================================================
    //======================================================================================================================
    //                                      DOCUMENTED FUNCTION
    //======================================================================================================================
 
public:
    enum CloudScriptTypesEnum
    {
        _3PI, // ShapeGrabber format
        _3PI_TRANSF, // ShapeGrabber format
        ASC_ESRI,
        ASC_SCAN,
        CSV_ASCII, // excel format
        CSV_CSLM, // excel format
        GSN_TRANF, // Transform patch into clouds
 
        // must be the last one
        AUTO_DETECT
    };
 
    enum struct OutputCloudsTypeClippPlanesEnum
    {
        Clipped,
        Unclipped,
        Both
    };
 
    enum struct OutputCloudsTypeInspectionValuesEnum
    {
        Inside,
        Outside,
        Both
    };
 
public slots:
    // TESTED
    static SCloud New();
 
    // TESTED
    static SCloud New(SCloud Other);
 
    static Array FromClick();
 
    // TESTED
    static Array FromName( String Name) { return SComp::GetFromName<SCloud>(Name); }
 
    // TESTED
    static Array FromSel();
 
    // TESTED
    static Array All(
        Number VisCrit
    )
    {
        return SComp::GetAll<SCloud>(VisCrit);
    }
 
    // TESTED
    static Array FromFile(
        String FileName, 
        CloudScriptTypesEnum IndexType, 
        Number NbPtToKeep, 
        Boolean ImportScanDir
    );
 
    static Array FromAsciiFile(
        String iFileName, 
        String iFormat, 
        Number iNbPtToKeep, 
        Boolean iImportScanDir
    );
 
    /
/
 
    // TESTED
    static Array Extract(
         Array<SComp> TableSComp, 
        Number SamplingDistance, 
        Boolean GenerateColor
    );
 
    static Array Merge(
         Array<SCloud> TableSCloud 
    );
 
    static Array ColorAlongDir(
         Array<SCloud> Clouds, 
         SVector DirectionVect, 
        SPoint iOrigin
    );
 
    static Array SeparateWithClippingObjects(
         Array<SCloud> iCloudOfPoints, 
        OutputCloudsTypeClippPlanesEnum iOutputCloudsType
    );
 
    static Array FilterWithInspectionValues(
         Array<SCloud> iCloudOfPoints, 
        Number iLowerThreshold, 
        Number iUpperThreshold, 
        OutputCloudsTypeInspectionValuesEnum iOutputCloudsType
    );
 
    static Array SeparateWithRealColors(
         Array<SCloud> iCloudOfPoints, 
        Number iColorR, 
        Number iColorG, 
        Number iColorB, 
        Number iTolerance 
    );
 
    static Array SeparateWithScanningPositions(
         Array<SCloud> iClouds, 
        Boolean CreateCloudWithoutScanningPositions 
    );
 
    static Array SeparateWithScanPatches(
         Array<SCloud> iClouds, 
        Boolean CreateCloudWithoutScanPatches 
    );
 
    static Array ExplodeCloudClassification(SCloud iCloud);
 
    static String toString();
 
    static Array ProjectGrid(
        SPoly iPoly,
        SPoint iOrigin,
         SVector iProjectionDir,
         SVector iHorizontalDir,
        Number iStepHorizontal,
        Number iStepVertical);
 
    static Array Classify(
         Array<SCloud> iClouds,  String iModelName);
 
    static QStringList GetClassificationModels();
 
    static Array GetCategoriesInModel( String iModelName);
 
    static Array GetClassName(Number iClassId);
};
Q_DECLARE_METATYPE(SCloud::_SCloudDummy);
Q_DECLARE_METATYPE(SCloud);
 
#ifndef FCT_DOC
} // namespace rsh::ScriptBinding
#endif // !FCT_DOC
 
#ifndef FCT_DOC
namespace rsh::Script::ScriptConvert
{
template<>
struct TblConvert<SCloud>
{
    static  char GetClassName() { return "SCloud"; } // return the name of the script class mapped with
 
    typedef SCloud ScriptClass; 
    typedef SCloud DCompClass;
 
    static SCloud GetGCompClass(SCloud _iCompClass)
    {
        return _iCompClass.GetGCloud();
    } // return the SComp from the SComp _iCompClass
 
    static SCloud ForDCompConstructor(SCloud _iEnt)
    {
        return _iEnt;
    } // return the correct SComp to create a new SComp
};
#endif
}