Deployment.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: Deployment
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/Vector.h>
#include <NDEVR/Buffer.h>
#include <NDEVR/Model.h>
#include <NDEVR/Geometry.h>
#include <NDEVR/TimeSpan.h>
#include <NDEVR/Angle.h>
#if NDEVR_DEPLOYMENT
namespace NDEVR
{
    struct Unit;
    class DesignObjectLookup;
    class Calibration;
    class StationModel;

    enum class DeploymentQualityFactor
    {
        e_none                
        , e_not_downloaded    
        , e_data_quality_good 
        , e_warning_quality   
        , e_warning_magnetometer 
        , e_invalid_reading   
        , e_data_quality_live 
        , e_out_of_bounds     
    };
    NDEVR_DESIGN_T_API template class NDEVR_DESIGN_API StringStream<DeploymentQualityFactor>;

    struct DeploymentRecord
    {
        Vector<3, Angle<fltp08>> computed_orientation = Vector<3, Angle<fltp08>>(Angle<fltp08>(DEGREES, 0.0)); 
        Vector<3, Angle<fltp08>> measured_orientation = Vector<3, Angle<fltp08>>(Angle<fltp08>(DEGREES, 0.0)); 
        fltp08 total_length = 0.0;  
        fltp08 length = 0.0;        
        Time surveyed_time;         
        Vertex<3, fltp08> location = Constant<Vertex<3, fltp08>>::Invalid; 
        Ray<3, fltp08> direction = Constant<Vertex<3, fltp08>>::Invalid;   
        UUID id = Constant<UUID>::Invalid; 
        DeploymentQualityFactor quality_factor = DeploymentQualityFactor::e_none; 

        bool operator==(const DeploymentRecord& record) const
        {
            return memcmp(this, &record, sizeof(DeploymentRecord)) == 0;
        }

        bool operator!=(const DeploymentRecord& record) const
        {
            return memcmp(this, &record, sizeof(DeploymentRecord)) != 0;
        }
    };

    class NDEVR_DESIGN_API Deployment : public Model
    {
    public:
        Deployment();

        explicit Deployment(const Model& root);

        Model addSegment(const Vector<3, fltp08>& location, bool animate = false, bool calc_linework = true);

        Model addSegment(fltp08 distance, Vector<3, Angle<sint04>> tilt, bool animate = false, bool calc_linework = true);

        Model addSegment(fltp08 distance, Vector<3, Angle<sint04>> tilt, const Unit& unit, bool animate = false, bool calc_linework = true);

        Model addSegment(fltp08 distance, Vector<3, Angle<fltp08>> tilt, bool animate = false, bool calc_linework = true);

        Model addSegment(fltp08 distance, Vector<3, Angle<fltp08>> tilt, const Unit& unit, bool animate = false, bool calc_linework = true);

        Model segment(uint04 index) const;

        void setQualityFactor(uint04 segment, DeploymentQualityFactor is_valid);

        static StringView QualityFactorIcon(DeploymentQualityFactor factor);

        static DeploymentQualityFactor QualityFactorIcon(const StringView& factor);

        void addSegments(const Buffer<Vertex<3, fltp08>>& locations, const Buffer<Time>& times = Buffer<Time>());

        Model deploymentLayer();

        DeploymentQualityFactor deploymentQuality() const;

        static UUID DeploymentLayerUUID();

        void ensureModelFormat(uint08 version);

        Model plannedLayer();

        static UUID PlannedLayerUUID();

        Model& deploymentLinework() { return m_linework_model; }

        Model& deploymentModels() { return m_deployment_model; }

        Model& visualModel() { return m_deployment; }

        void removeSegment(uint04 segment_index, bool update_linework = true);

        void removeAllSegments();

        void straightenSegment(uint04 segment_index);

        Vertex<3, fltp08> endPoint() const;

        void updateEndpoint(const Vertex<3, fltp08>& end_point);

        Vector<3, Angle<fltp08>> lastTilt() const;

        const Buffer<DeploymentRecord>& records() const;

        fltp08 deploymentLength() const;

        fltp08 currentLocationLength() const;

        Vertex<3, fltp08> currentLocation() const;

        fltp08 addToLocationLengthAndReturnRemainder(fltp08 length);

        void setCurrentLocationLength(fltp08 length);

        uint04 recordCount() const;

        void setUseTube(Geometry::ThicknessMode mode, fltp08 radius);

        fltp08 tubeThickness() const;

        void setUseModel();

        void updateIconFromReadings();

        fltp08 locationAt(const Vertex<3, fltp08>& location) const;

        Vertex<3, fltp08> pointAtLength(fltp08 location) const;

        StationModel getStation() const;

        Calibration getCalibration() const;

        Effect invalidSegmentEffect();

        Effect growEffect() const;

        bool isHorizontal() const;

        bool isVertical() const;

        void cancelGrowEffect();

        bool hasMissingRecords() const;

        void updateLineworkFromRecords(uint04 start_index = 0);

        void updateModelsFromRecords(uint04 start_index = 0);
 
        // ----------------------------------------------------------------------------
        // Finds the closest record to given time (While not exceeding max_time),
        // updates that record with the new angle, and returns the index of the updated record.
        // Parameters:
        // time - The time of angle reading. The closest segment in time will be chosen
        // angle - The value of the angle in the units specified by type.
        // ----------------------------------------------------------------------------

        uint04 adjustTilt(const Time& time, const Vector<3, Angle<sint04>>& angle, TimeSpan max_time = TimeSpan(2.0));

        uint04 adjustTilt(const Time& time, const Vector<3, Angle<fltp08>>& angle, TimeSpan max_time = TimeSpan(2.0));

        void adjustLength(uint04 segment, fltp08 length);

        void adjustTilt(uint04 segment, const Vector<3, Angle<fltp08>>& angle);

        Polyline<3, fltp08> toPolyline() const;

        void cleanup();

        bool isPlanned() const;

        void setIsPlanned(bool is_design);

        void setupAsDefaultPlanned(bool add_segment);

        Deployment getPlanned() const;

        void setupInvalidEffect();

        static Deployment GetAssociatedPlan(const Model& model);

        static constexpr StringView TypeName() { return "deployment"; }

        static constexpr StringView DecorationTypeName() { return "deployment_decoration"; }
 
        static DynamicPointer<Model> s_deployment_model; 

        static void SetupMaterialToLayerDefaults(Material& mat);
    private:
        UUID growTarget() const;

        uint04 segmentCount() const;

        void setupDeploymentModel();

        void createSegmentChild();

        void setupLineworkGeometry();

        void calculateRecords(uint04 segment = 0) const;

        void updateRecordLocations(uint04 segment = 0) const;

        void setRecord(uint04 index, const DeploymentRecord& record) const;

        void initialize();

        void validateRecords() const;

        void ensureRecordsCached() const;
    protected:
        bool m_is_init;                                
        mutable Buffer<DeploymentRecord> m_cached_records; 
        mutable Time m_record_cache_time;              
        Model m_deployment;                            
        Model m_deployment_model;                      
        Model m_linework_model;                        
    };
}
#endif