JsonTranslator.h

Go to the documentation of this file.

//------------------------------------------------------------------------------
//
// visuReal Zentrierdaten-Ermittlung
//
// Original file: JsonTranslator.h
//
//   Robert Rossmair, 2011-2013
//
// Copyright © 2011 Ollendorf Measurement Systems
//   Dipl.-Ing. Hans-Joachim Ollendorf
//   Zur Springe 5
//   39517 Brunkau
//   Germany
//
//------------------------------------------------------------------------------

#ifndef JSONTRANSLATOR_H
#define JSONTRANSLATOR_H

#include <memory>
#include <math.h>
#include <limits>
#include "chain/ApiTypes.h"
#include "StatusUtils.h"
#include "visuReal.core/visuReal.core.h"

const double indeterminate = std::numeric_limits<double>::quiet_NaN();

namespace vr
{

const size_t FRONTAL_MARK_COUNT         = 5;
const size_t NEAR_PD_MARK_COUNT         = 3;
const size_t LATERAL_MARK_COUNT         = 3;
const size_t EYE_COUNT                  = 2;
const size_t LENSBOX_CORNER_COUNT       = 4;
const size_t WINDROSE_DIRECTION_COUNT   = 4;
const size_t LATERALBOX_CORNER_COUNT    = 3;
const size_t STRUT_LENSCONTOUR_INTERSECTION_COUNT = 4;

const json_string jsCameraAttitude  = "camera_attitude";
const json_string jsDetails         = "details";

const json_string jsExposureArrangement = "exposure_arrangement";

const json_string jsImages          = "images";
const json_string jsFile            = "file";
const json_string jsImage           = "image";
const json_string jsOpticalAxis     = "optical_axis";
const json_string jsStatus          = "status";
const json_string jsResultImage     = "result_image";
const json_string jsSize            = "size";
const json_string jsFront           = "front";
const json_string jsNearFront       = "near_front";
const json_string jsRight           = "right";
const json_string jsLeft            = "left";

const json_string jsMethod          = "method";

const json_string jsNoMethod        = "";
const json_string jsFrontOnly       = "front";
const json_string jsRightSideFront  = "front+right";
const json_string jsFrontLeftSide   = "front+left";
const json_string jsRightSideFrontLeftSide = "front+right+left";

const json_string jsRealizedSize    = "realised_size";
const json_string jsMinimumSize     = "minimum_size";
const json_string jsMaximumSize     = "maximum_size";
const json_string jsMinimumMarkMargin = "minimum_mark_margin";

const json_string jsTransformation  = "transformation";
const json_string jsImageSize       = "image_size";
const json_string jsClippingOffset  = "clipping_offset";
const json_string jsPivot           = "pivot";
const json_string jsAngle           = "angle";
const json_string jsScaleFactor     = "scale_factor";
const json_string jsProgressiveCorridorLength = "progressive_corridor_length";
const json_string jsComputationModel = "computation_model";

const json_string jsMarks           = "marks";
const json_string jsIris            = "iris";
const json_string jsLens            = "lens";
const json_string jsLensL           = "lens_L";
const json_string jsLensR           = "lens_R";
const json_string jsLensMarginL     = "lens_margin_L";
const json_string jsLensMarginR     = "lens_margin_R";
const json_string jsCenter          = "center";
const json_string jsDiameter        = "diameter";
const json_string jsSpherical       = "spherical";
const json_string jsAspheric        = "aspheric";
const json_string jsProgressive     = "progressive";
const json_string jsMETS            = "hoya_mets";
const json_string jsBox             = "box";
const json_string jsPlanePixelsPerMm = "plane_pixels_per_mm";
const json_string jsFaceFormAngleRef   = "face_form_angle_ref";
const json_string jsInfantGlassesConfig = "infant_glasses_config";
const json_string jsMarkMarginInPercent = "percentage_mark_margin";
const json_string jsProgressiveCorridorTop = "progressive_corridor_top";
const json_string jsProgressiveCorridorBottom = "progressive_corridor_bottom";
const json_string jsStrutLensContourIntersections = "strut_lens_contour_intersections";
const json_string jsLensBevels      = "lens_bevels";
const json_string jsLensThickness   = "lens_thickness";
const json_string jsResults         = "results";
const json_string jsPreciseResults  = "precise_results";

const json_string jsGrooveDepth [GROOVE_DEPTH_CLASS] = {
    "groove depth: 0",
    "groove depth: 0.5 mm",
    "groove depth: 0.7 mm"
};

const json_string jsHeadRotationCompensationOff = "head rotation compensation: off";
const json_string jsHeadRotationCompensationOn  = "head rotation compensation: on";
const json_string jsReadingDistance = "reading_distance";
const json_string jsVarioInsetTop = "up";
const json_string jsVarioInsetMiddle = "middle";
const json_string jsVarioInsetBottom = "down";

JSONNode& getJsonNode(JSONNode& parent, char nodeType, const json_string& name, bool clear = false);
JSONNode& getEmptyJsonNode(JSONNode& parent, const json_string& name);
JSONNode& getEmptyJsonArray(JSONNode& parent, const json_string& name);

//------------------------------------------------------------------------------

template<size_t n> class IntArray
{
public:
    IntArray(const json_string& key, int initValue = 0)
    {
        for (size_t i = 0; i < n; i++)
        {
            values[i] = initValue;
        }
        key_ = key;
    };

    bool tryReadFromJson(const JSONNode& node)
    {
        if (node.name() == key_) {

            JSONNode::const_iterator i = node.begin();

            for (size_t j = 0; j < n; j++) {
                if (i != node.end()) {
                    values[j] = i->as_int();
                    ++i;
                };
            };
            return true;
        }
        return false;
    };

    void writeToJson(JSONNode& parent)
    {
        JSONNode& node = getEmptyJsonArray(parent, key_);
        JSONNode value(JSON_NUMBER);

        for (size_t j = 0; j < n; j++) {
            value = values[j];
            node.push_back(value);
        };
    }
    
    void writeToVrCore(void (*setter)(const int values[])) { setter(values); };
    void writeToVrCore(void (*setter)(const int values[], const LateralSide partialImage)) { setter(values, RIGHT); };
    void readFromVrCore(void (*getter)(int values[])) { getter(values); };
private:    
    int values[n];
    json_string key_;
};

//------------------------------------------------------------------------------

template<size_t n> class IntArrayWithStatus
{
public:
    IntArrayWithStatus(const json_string& key, int initValue = 0)
    {
        for (size_t i = 0; i < n; i++)
        {
            values[i] = initValue;
        }
        key_ = key;
        info_ = guessed;
    };

    bool tryReadFromJson(const JSONNode& node)
    {
        if (node.name() == key_) {
            JSONNode::const_iterator k = node.begin();
            readStatusFromJson(*k++, info_);
            JSONNode::const_iterator i = (*k).begin();
            for (size_t j = 0; j < n; j++) {
                if (i != (*k).end()) {
                    values[j] = i->as_int();
                    ++i;
                };
            };
            return true;
        }
        return false;
    };

    void writeArrayToJson(JSONNode& parent) const
    {
        JSONNode node(JSON_ARRAY);

        if (!(parent.name() == key_))
            node.set_name(key_);

        JSONNode value(JSON_NUMBER);

        for (size_t j = 0; j < n; j++) {
            value = values[j];
            node.push_back(value);
        };

        parent.push_back(node);
    }

    void writeToJson(JSONNode& parent)
    {
        JSONNode& node = getEmptyJsonArray(parent, key_);

        JSONNode s(JSON_STRING);
        writeStatusToJson(s, info_);
        node.push_back(s);

        writeArrayToJson(node);
        /*
        JSONNode& array = getEmptyJsonArray(node, key_);
        JSONNode value(JSON_NUMBER);

        for (size_t j = 0; j < n; j++) {
            value = values[j];
            array.push_back(value);
        };
         */
    }

    void writeToVrCore(void (*setter)(const int values[], const StatusInfo info_)) { setter(values, info_); };
    void readFromVrCore(StatusInfo  (*getter)(int values[])) { info_ = getter(values); };
    int& operator [](size_t i) { return values[i]; };
private:
    int values[n];
    json_string key_;
    StatusInfo info_;
};

//------------------------------------------------------------------------------

template<size_t n> class DoubleArray
{
public:
    DoubleArray(const json_string& key)
    {
        for (size_t i = 0; i < n; i++)
        {
            values_[i] = indeterminate;
        }
        key_ = key;
    };
    
    bool tryReadFromJson(const JSONNode& node)
    {
        if (node.name() == key_) {
            JSONNode::const_iterator i = node.begin();
            for (size_t j = 0; j < n; j++) {
                if (i != node.end()) {
                    values_[j] = i->as_float();
                    ++i;
                };
            };
            return true;
        }
        return false;
    };

    void writeToJson(JSONNode& parent)
    {
        JSONNode& node = getEmptyJsonArray(parent, key_);
        JSONNode value(JSON_NUMBER);

        for (size_t j = 0; j < n; j++) {
            double x = values_[j];
            if (!std::isfinite(x))
                value = JSON_NULL;
            else
                value = x;
            node.push_back(value);
        };
    }
    
    void writeToVrCore(void (*setter)(const double values[]))
    {
        if (values_[0] == values_[0]) // !NaN
            setter(values_); 
    };
    void readFromVrCore(void (*getter)(double values[])) { getter(values_); };

    double& operator [](size_t i) { return values_[i]; };
private:    
    double values_[n];
    json_string key_;
};

//------------------------------------------------------------------------------

template<size_t n> class CoordinateSet
{
public:
    CoordinateSet()
    {
        for (size_t i = 0; i < n; i++)
        {
#if 1
            coordinates[i][0] = 0.0;
            coordinates[i][1] = 0.0;
            info[i] = todo;
#else
            coordinates[i][0] = indeterminate;
            coordinates[i][1] = indeterminate;
            info[i] = invalid;
#endif
        }
    };
    void readFromJson(const JSONNode& node, const char* id[n])
    {
        for (size_t i = 0; i < n; i++)
        {
            JSONNode j = node[id[i]];
            readStatusFromJson(j[0], info[i]);
            coordinates[i][0] = (j[1][0].as_float());
            coordinates[i][1] = (j[1][1].as_float());
        }
    };

    void writeToJson(JSONNode& node, const char* id[n])
    {
        //if (isValid())
            for (size_t i = 0; i < n; i++)
            {
                JSONNode a(JSON_ARRAY);
                a.set_name(id[i]);

                JSONNode s(JSON_STRING);
                writeStatusToJson(s, info[i]);
                a.push_back(s);

                JSONNode a1(JSON_ARRAY);
                    JSONNode c(JSON_NUMBER);
                    double x = coordinates[i][0];
                    if (!std::isfinite(x))
                        c = JSON_NULL;
                    else
                        c = x;
                    a1.push_back(c);
                    x = coordinates[i][1];
                    if (!std::isfinite(x))
                        x = JSON_NULL;
                    c = x;
                    a1.push_back(c);
                a.push_back(a1);

                node.push_back(a);
            }
    };
    void writeToVrCore(void (*setter)(const double points[][2], const StatusInfo info[]))
    {
        if (isValid())
            setter(coordinates, info);
    };
    void writeToVrCore(void (*setter)(const double points[][2], const StatusInfo info[], const LateralSide partialImage))
    {
        if (isValid())
            setter(coordinates, info, RIGHT);
    };
    void writeToVrCore(void (*setter)(const double points[][2], const StatusInfo info[], VarioInsetPos, size_t), VarioInsetPos p, size_t i)
    {
        if (isValid())
            setter(coordinates, info, p, i);
    };
    void readFromVrCore(void (*getter)(double points[][2], StatusInfo info[])) { getter(coordinates, info); };
    void readFromVrCore(void (*getter)(double points[][2], StatusInfo info[], const LateralSide partialImage)) { getter(coordinates, info, RIGHT); };
    void readFromVrCore(void (*getter)(double points[][2], StatusInfo info[], VarioInsetPos, size_t), VarioInsetPos p, size_t i)
        { getter(coordinates, info, p, i); };
    bool isValid() { return info[0] != invalid; };

    void getPoints(std::vector<cv::Point2d>& points) const {
        for (size_t i = 0; i < n; i++) {
            points.push_back(cv::Point2d(
                coordinates[i][0],
                coordinates[i][1]));
        };
    };

    void get(double points[n][2], StatusInfo statusInfo[n]) {
        for (size_t i = 0; i < n; i++) {
            points[i][0] = coordinates[i][0];
            points[i][1] = coordinates[i][1];
            statusInfo[i] = info[i];
        };
    };
    void set(double points[n][2], StatusInfo statusInfo[n]) {
        for (size_t i = 0; i < n; i++) {
            coordinates[i][0] = points[i][0];
            coordinates[i][1] = points[i][1];
            info[i] = statusInfo[i];
        };
    };
private:    
    double coordinates[n][2];
    StatusInfo info[n];
};

//------------------------------------------------------------------------------

class JsonPoint : public cv::Point_<json_number>
{
public:
    JsonPoint(const json_string& key) : key_(key) {};
    bool tryReadFromJson(const JSONNode& node)
    {
        if (node.name() == key_) {
            x = node["x"].as_float();
            y = node["y"].as_float();
            return true;
        };
        return false;
    };
    void writeToJson(JSONNode& parent)
    {
        JSONNode& node = getEmptyJsonNode(parent, key_);

        JSONNode c(JSON_NUMBER);
            c.set_name("x");
            c = x;
            node.push_back(c);

            c.set_name("y");
            c = y;
            node.push_back(c);
    };
private:
    json_string key_;
};

//------------------------------------------------------------------------------

template <typename T> class JsonValue
{
public:
    JsonValue(json_string key, T value) : key_(key), value_(value) {};
    bool tryReadFromJson(const JSONNode& node)
    {
        if (node.name() == key_) {
            setValue(node);
            return true;
        }
        return false;
    };
    void writeToVrCore(void (*setter)(const T value))
    {
            setter(value_);
    };
    void readFromVrCore(T (*getter)()) { value_ = getter(); };
    void writeToJson(JSONNode& parent)
    {
        JSONNode& value = getEmptyJsonNode(parent, key_);
        value = value_;
    };
    inline void setValue(const JSONNode& node);
    void setValue(T value, StatusInfo status = guessed)
    {
        value_ = value;
    };
    T getValue() const { return value_; };
private:
    json_string key_;
    T value_;
};

//------------------------------------------------------------------------------

template <typename T> class ValueWithStatus
{
public:
    ValueWithStatus(json_string key, T value) : key_(key), value_(value), status_(invalid) {};
    bool tryReadFromJson(const JSONNode& node)
    {
        if (node.name() == key_) {
            readStatusFromJson(node[0], status_);
            setValue(node[1]);
            return true;
        }
        return false;
    };
    void writeToVrCore(void (*setter)(const T value, const StatusInfo& statusInfo))
    {
        if (status_ != invalid)
            setter(value_, status_);
    };
    void readFromVrCore(T (*getter)(StatusInfo& info)) { value_ = getter(status_); };
    void writeToJson(JSONNode& parent)
    {
        if (status_ == invalid)
            status_ = guessed;
        JSONNode& node = getEmptyJsonArray(parent, key_);

        JSONNode s(JSON_STRING);
        writeStatusToJson(s, status_);
        node.push_back(s);

        JSONNode value(JSON_BOOL);
        value = value_;
        node.push_back(value);
    };
    inline void setValue(const JSONNode& node);
    void setValue(T value, StatusInfo status = guessed)
    {
        value_ = value;
        status_ = status;
    };
    T getValue() const { return value_; };
private:
    json_string key_;
    T value_;
    StatusInfo status_;
};

typedef ValueWithStatus<bool> BoolValue;
typedef ValueWithStatus<int> IntValue;
typedef ValueWithStatus<double> DoubleValue;

//------------------------------------------------------------------------------

class JsonTranslator {
    friend class CoreViewer;
public:
    JsonTranslator();
    ~JsonTranslator();
   
    bool readFromJson(JSONNode& rootNode);
    void writeToJson(JSONNode& rootNode);
    void writeToVrCore();
    void readFromVrCore();

    class ImageData 
    {
    public:
        ImageData();
        ~ImageData();

        const std::string& getFileName() const;
        void setFileName(const std::string& fileName);
        StatusInfo getStatusInfo() const;
        void setStatusInfo(const StatusInfo statusInfo);

        virtual bool readFromJson(const JSONNode& node);
        virtual bool writeToJson(JSONNode& node);
        virtual void writeToVrCore(void (*setCameraAttitude)(const double [3]),
                                   void (*setOpticalAxis)(const double [2]),
                                   void (*setPercentageMarkMargins)(const int [4]));
        virtual void writeToVrCore(void (*setCameraAttitude)(const double [3]),
                                   void (*setOpticalAxis)(const double [2]),
                                   void (*setPercentageMarkMargins)(const int [4], const LateralSide));
        virtual void readFurther(const JSONNode& node) = 0;
    protected:
        class ResultImage {
            friend class CoreViewer;
        public:
            ResultImage();
            void readJson(const JSONNode& node);
            void writeJson(JSONNode& node);
            void readFromVrCore(StatusInfo (*getStatusInfo)());
            void writeToVrCore(void (*setter) (const char*, const StatusInfo));
            void writeToVrCore(void (*setter) (const char*, const StatusInfo, const LateralSide));
            std::string fileName_;
            StatusInfo statusInfo_;
        } resultImage;

        class Transformation {
        public:
            Transformation();
            void readJson(const JSONNode& node);
            void writeJson(JSONNode& node);
            void readFromVrCore(void (*getter)(int [2], int [2], double [2], double&));
            void readFromVrCore(void (*getter)(int [2], int [2], double [2], double&, const LateralSide));
            void writeToVrCore(void (*setter)(const int [2], const int [2], const double [2], const double));
            void writeToVrCore(void (*setter)(const int [2], const int [2], const double [2], const double, const LateralSide));
        private:
            int imageSize_ [2];
            int clippingOffset_ [2];
            double pivot_ [2];
            double angle_;
            bool isValid() const;
        } transformation;
    private:
        double par_;
        std::string fileName_;
        double opticalAxis_ [2];
        double cameraUp_ [3];
        IntArray<WINDROSE_DIRECTION_COUNT> markMarginsInPercent_;
        StatusInfo statusInfo_;
        SubStatus subStatus_;
        bool readCameraAttitudeFromJson(const JSONNode& node);
    };
    
    class FrontImageData : public ImageData
    {
        friend class CoreViewer;
    public:
        FrontImageData();
        bool readFromJson(const JSONNode& node);
        void readFurther(const JSONNode& node);
        bool writeToJson(JSONNode& node);
        void writeMetsArrayToJson(JSONNode& node) const;
        void writeToVrCore();
        void readFromVrCore();
        const IntValue& lensDiameter(LensType lensType, LateralSide side) const { return (side == _R) ? lensDiameter_[lensType][_R] : lensDiameter_[lensType][_L]; };
    private:
        class LensBox {
        public:
            CoordinateSet<LENSBOX_CORNER_COUNT> Corners;
            CoordinateSet<LENSBOX_CORNER_COUNT> Margins;
        };
    private:
        class ProgressiveCorridor {
        public:
            CoordinateSet<EYE_COUNT> Tops;
            CoordinateSet<EYE_COUNT> Bottoms [GROOVE_DEPTH_CLASS];
        };

        CoordinateSet<FRONTAL_MARK_COUNT>   marks_;
        CoordinateSet<EYE_COUNT>            irides_;
        CoordinateSet<EYE_COUNT>            faceFormAngleRefs_;
        LensBox lensBox_[LATERAL_SIDE];
        //lensBox lensBoxL_;
        CoordinateSet<EYE_COUNT> lensCenter_[LENS_TYPE];
        ValueWithStatus<int> lensDiameter_[LENS_TYPE][LATERAL_SIDE];
        DoubleArray<2> lensPlanePixelsPerMm_[LATERAL_SIDE];
        IntArrayWithStatus<4> hoyaMETS_;
        ProgressiveCorridor progressiveCorridor_;
        CoordinateSet<STRUT_LENSCONTOUR_INTERSECTION_COUNT> strutLensContourIntersections_;
        BoolValue infantGlassesConfig_;

        void readProgressiveCorridorBottoms(const JSONNode& node);
        void readLensData(const JSONNode& node, const LensType lensType);
        void writeLensData(JSONNode& node, const LensType lensType);
    };

    class VarioInsetImageData : public ImageData
    {
    public:
        VarioInsetImageData(VarioInsetPos varioInsetPos, size_t index);
        void readFurther(const JSONNode& node);
        bool writeToJson(JSONNode& node);
        void writeToVrCore();
        void readFromVrCore();

    private:
        CoordinateSet<FRONTAL_MARK_COUNT>   marks_;
        CoordinateSet<EYE_COUNT>            irides_;
        float readingDistance_;
        VarioInsetPos varioInsetPos_;
        size_t index_;
    };

    class VarioInsetImages {
        std::vector<VarioInsetImageData> top_;
        std::vector<VarioInsetImageData> middle_;
        std::vector<VarioInsetImageData> bottom_;
    public:
        VarioInsetImages();
        void readImages(const JSONNode& node, std::vector<VarioInsetImageData>& images, VarioInsetPos p);
        void writeImages(JSONNode& node, std::vector<VarioInsetImageData>& images);
        bool readFromJson(const JSONNode& node);
        void writeToJson(JSONNode& node);
        void writeToVrCore();
        void readFromVrCore();
    };

    class SideImageData : public ImageData
    {
        friend class CoreViewer;
    private:
        LateralSide side_;
        CoordinateSet<LATERAL_MARK_COUNT>      marks_;
        CoordinateSet<LATERALBOX_CORNER_COUNT> boxCorners_;
    public:
        SideImageData(LateralSide side) : ImageData() { side_ = side; };
        void readFurther(const JSONNode& node);
        bool writeToJson(JSONNode& node);
        // Redundanz, ich hass dich ganz
        void readFromVrCoreR();
        void readFromVrCoreL();
        void writeToVrCoreR();
        void writeToVrCoreL();
        
    };

    void display();

private:
    MeasuringMethod method_;
    ExposureArrangement exposureArrangement_;
    double correction_;

    FrontImageData front_;
    SideImageData right_;
    SideImageData left_;
    DoubleArray<2> grooveDepth_;
    double lensThickness_;

    VarioInsetImages nearFront_;
    int computationModel_;
    bool hasNearFront_;

    void readRightSideFromVrCore();
    void readLeftSideFromVrCore();
    void writeRightSideToVrCore();
    void writeLeftSideToVrCore();
    bool methodNeeds(JsonTranslator::ImageData& image) const;

    void createGrooveDepthBranch(JSONNode& parent, GrooveDepthClass grooveDepthClass, const bool rounded);
    void createGrooveDepthBranches(JSONNode& parent, const bool rounded);
    void createResultList(JSONNode& node, const Results& results, const bool rounded) const;
};

} // namespace vr
#endif // JSONTRANSLATOR_H