public void Write(OmaReaderDoubleResult OmaReaderDoubleResult, computeLensResponseDTO leftComputeLensResponseDTO, computeLensResponseDTO rightComputeLensResponseDTO)
        {
            SurfaceFiles tmpSurfaceFiles = TempSurfaceFilesPath(OmaReaderDoubleResult);
            string       leftTmpPath     = tmpSurfaceFiles.LeftSurfaceFile;
            string       rightTmpPath    = tmpSurfaceFiles.RightSurfaceFile;

            File.Delete(leftTmpPath);
            File.Delete(rightTmpPath);
            Write(rightTmpPath, rightComputeLensResponseDTO, side.RIGHT);
            Write(leftTmpPath, leftComputeLensResponseDTO, side.LEFT);
            SurfaceFiles surfaceFiles  = SurfaceFilesPath(OmaReaderDoubleResult);
            string       leftFilePath  = surfaceFiles.LeftSurfaceFile;
            string       rightFilePath = surfaceFiles.RightSurfaceFile;

            File.Delete(leftFilePath);
            File.Delete(rightFilePath);
            if (File.Exists(leftTmpPath))
            {
                File.Move(leftTmpPath, leftFilePath);
            }
            if (File.Exists(rightTmpPath))
            {
                File.Move(rightTmpPath, rightFilePath);
            }
        }
        public AnalizedLensPage(computeLensRequestDTO computeLensRequest, computeLensResponseDTO computeLensResponse)
        {
            InitializeComponent();

            this.computeLensRequest  = computeLensRequest;
            this.computeLensResponse = computeLensResponse;
        }
        private void Write(OmaReaderDoubleResult OmaReaderDoubleResult, computeLensResponseDTO left, computeLensResponseDTO right, OmaEvent OmaEvent)
        {
            AbstractSurfaceOmaWriter <threeDimensionalPointDTO> surfaceOmaWriter;

            switch (Enum.TryParse(configuration.AppSettings.Settings[OUTPUT_FORMAT].Value, out OutputFormat outputFormat) ? outputFormat : OutputFormat.sdf)
            {
            case OutputFormat.sdf:
                surfaceOmaWriter = SDFWriter;
                break;

            case OutputFormat.hmf:
                surfaceOmaWriter = HMFWriter;
                break;

            default:
                surfaceOmaWriter = XYZWriter;
                break;
            }
            surfaceOmaWriter.Write(OmaReaderDoubleResult, left, right);
            SurfaceFiles        surfaceFiles = surfaceOmaWriter.SurfaceFilesPath(OmaReaderDoubleResult);
            IFilePathOmaBuilder filePathOmaBuilder;

            if (surfaceFiles.LeftSurfaceFile.Equals(surfaceFiles.RightSurfaceFile))
            {
                filePathOmaBuilder = new SingleFilePathOmaBuilder(surfaceFiles.LeftSurfaceFile);
            }
            else
            {
                filePathOmaBuilder = new DoubleFilePathOmaBuilder(surfaceFiles.RightSurfaceFile, surfaceFiles.LeftSurfaceFile);
            }
            AnalysisWriter.Write(OmaReaderDoubleResult, left, right);
            OmaWriter.Write(OmaReaderDoubleResult, left, right, surfaceFiles.LeftSurfaceFile, surfaceFiles.RightSurfaceFile, filePathOmaBuilder);
            Logger.LogEvent(OmaEvent, EventLogEntryType.Information, EventTypes.Result);
        }
        protected void Write(string filePath, computeLensResponseDTO computeLensResponseDTO, side side)
        {
            if (computeLensResponseDTO is object && computeLensResponseDTO.value is object && computeLensResponseDTO.value.points is object)
            {
                IEnumerable <T> points    = computeLensResponseDTO.value.points.Select(point => point as T);
                double          dimension = Math.Abs(points.First().x) * 2;

                using (StreamWriter streamWriter = new StreamWriter(filePath, true, Encoding.ASCII))
                {
                    Write(points, streamWriter, dimension, side);
                }
            }
        }
Esempio n. 5
0
        public void Write(OmaReaderSingleResult OmaReaderSingleResult, computeLensResponseDTO computeLensResponse, string surfaceFile, IFilePathOmaBuilder filePathBuilder)
        {
            switch (OmaReaderSingleResult)
            {
            case OmaReaderLeftResult OmaReaderLeftResult:
                Write(OmaReaderLeftResult.Result, null, computeLensResponse, null, surfaceFile, null, filePathBuilder);
                break;

            case OmaReaderRightResult OmaReaderRightResult:
                Write(null, OmaReaderRightResult.Result, null, computeLensResponse, null, surfaceFile, filePathBuilder);
                break;
            }
        }
        public void Write(OmaReaderSingleResult OmaReaderSingleResult, computeLensResponseDTO computeLensResponseDTO)
        {
            side   side    = OmaReaderSingleResult is OmaReaderLeftResult ? side.LEFT : side.RIGHT;
            string tmpPath = TempSurfaceFilePath(OmaReaderSingleResult);

            File.Delete(tmpPath);
            Write(tmpPath, computeLensResponseDTO, side);
            string filePath = SurfaceFilePath(OmaReaderSingleResult);

            File.Delete(filePath);
            if (File.Exists(tmpPath))
            {
                File.Move(tmpPath, filePath);
            }
        }
        private void Write(OmaReaderSingleResult OmaReaderSingleResult, computeLensResponseDTO response, OmaEvent OmaEvent)
        {
            AbstractSurfaceOmaWriter <threeDimensionalPointDTO> surfaceOmaWriter;
            OutputFormat outputFormat;

            outputFormat = Enum.TryParse(configuration.AppSettings.Settings[OUTPUT_FORMAT].Value, out outputFormat) ? outputFormat : OutputFormat.sdf;
            switch (outputFormat)
            {
            case OutputFormat.sdf:
                surfaceOmaWriter = SDFWriter;
                break;

            case OutputFormat.hmf:
                surfaceOmaWriter = HMFWriter;
                break;

            default:
                surfaceOmaWriter = XYZWriter;
                break;
            }
            surfaceOmaWriter.Write(OmaReaderSingleResult, response);
            string surfaceFilePath = surfaceOmaWriter.SurfaceFilePath(OmaReaderSingleResult);
            IFilePathOmaBuilder filePathOmaBuilder;

            switch (outputFormat)
            {
            case OutputFormat.sdf:
                filePathOmaBuilder = new SingleFilePathOmaBuilder(surfaceFilePath);
                break;

            default:
                switch (OmaReaderSingleResult)
                {
                case OmaReaderLeftResult OmaReaderLeftResult:
                    filePathOmaBuilder = new DoubleFilePathOmaBuilder(null, surfaceFilePath);
                    break;

                default:
                    filePathOmaBuilder = new DoubleFilePathOmaBuilder(surfaceFilePath, null);
                    break;
                }
                break;
            }
            AnalysisWriter.Write(OmaReaderSingleResult, response);
            OmaWriter.Write(OmaReaderSingleResult, response, surfaceFilePath, filePathOmaBuilder);
            Logger.LogEvent(OmaEvent, EventLogEntryType.Information, EventTypes.Result);
        }
        private async void ComputeLens()
        {
            IsBusy = true;

            computeLensRequestDTO request = null;

            switch (Design)
            {
            case LensType.Digit:
                request = new computeDigitLensRequestDTO()
                {
                    far              = FarZone,
                    farSpecified     = true,
                    near             = NearZone,
                    nearSpecified    = true,
                    channel          = Channel,
                    channelSpecified = true
                };
                break;

            case LensType.Punctual:
                request = new computePunctualLensRequestDTO()
                {
                    channel          = Channel,
                    channelSpecified = true
                };
                break;

            case LensType.Vario:
                request = new computeVarioLensRequestDTO()
                {
                    far              = FarZone,
                    farSpecified     = true,
                    near             = NearZone,
                    nearSpecified    = true,
                    channel          = Channel,
                    channelSpecified = true
                };
                break;

            case LensType.Iflex:
                request = new computeIflexLensRequestDTO()
                {
                    far              = FarZone,
                    farSpecified     = true,
                    near             = NearZone,
                    nearSpecified    = true,
                    channel          = Channel,
                    channelSpecified = true
                };
                break;

            case LensType.Iprof:
                request = new computeIprofLensRequestDTO()
                {
                    near             = NearZone,
                    nearSpecified    = true,
                    channel          = Channel,
                    channelSpecified = true
                };
                break;

            case LensType.Iprog:
                request = new computeIprogLensRequestDTO()
                {
                    near             = NearZone,
                    nearSpecified    = true,
                    channel          = Channel,
                    channelSpecified = true
                };
                break;

            case LensType.Magic:
                request = new computeMagicLensRequestDTO();
                break;

            case LensType.Office:
                request = new computeOfficeLensRequestDTO();
                break;

            case LensType.Fantasy:
                request = new computeFantasyLensRequestDTO();
                break;
            }

            request.preview                                   = false;
            request.previewSpecified                          = true;
            request.verticalPrismThinning                     = true;
            request.verticalPrismThinningSpecified            = true;
            request.horizontalPrismThinning                   = false;
            request.horizontalPrismThinningSpecified          = true;
            request.horizontalPrismThinningHeight             = 0;
            request.horizontalPrismThinningHeightSpecified    = true;
            request.prismThinningCompensation                 = false;
            request.prismThinningCompensationSpecified        = true;
            request.maximumPrismThinningCompensation          = 0;
            request.maximumPrismThinningCompensationSpecified = true;
            request.atoric                      = false;
            request.atoricSpecified             = true;
            request.pantoscopicAngle            = 9;
            request.pantoscopicAngleSpecified   = true;
            request.wrappingAngle               = 6;
            request.wrappingAngleSpecified      = true;
            request.backVertexDistance          = 13;
            request.backVertexDistanceSpecified = true;
            request.eyeDiameter                 = 26;
            request.eyeDiameterSpecified        = true;
            request.readDistance                = 330;
            request.readDistanceSpecified       = true;

            request.left = new computeLensRequestSideDTO()
            {
                sphere                               = LeftSphere,
                sphereSpecified                      = true,
                cylinder                             = LeftCylinder,
                cylinderSpecified                    = true,
                cylinderAxis                         = LeftCylinderAxis,
                cylinderAxisSpecified                = true,
                addiction                            = LeftAddiction,
                addictionSpecified                   = true,
                horizontalDiameter                   = 70,
                horizontalDiameterSpecified          = true,
                verticalDiameter                     = 70,
                verticalDiameterSpecified            = true,
                refractiveIndex                      = RefractionIndex.Value,
                refractiveIndexSpecified             = true,
                toolRealBase                         = LeftToolRealBase,
                toolRealBaseSpecified                = true,
                toolIndex                            = 1.498,
                toolIndexSpecified                   = true,
                prescriptedPrism                     = 0,
                prescriptedPrismSpecified            = true,
                prescriptedPrismBase                 = 0,
                prescriptedPrismBaseSpecified        = true,
                secondaryPrism                       = 0,
                secondaryPrismSpecified              = true,
                secondaryPrismBase                   = 0,
                secondaryPrismBaseSpecified          = true,
                minimalCentralThickness              = 2,
                minimalCentralThicknessSpecified     = true,
                minimalSideThickness                 = 2,
                minimalSideThicknessSpecified        = true,
                horizontalDecentralization           = 0,
                horizontalDecentralizationSpecified  = true,
                verticalDecentralization             = 0,
                verticalDecentralizationSpecified    = true,
                monocularCentrationDistance          = 32,
                monocularCentrationDistanceSpecified = true,
                inset          = 2.2,
                insetSpecified = true
            };
            request.right = new computeLensRequestSideDTO()
            {
                sphere                               = RightSphere,
                sphereSpecified                      = true,
                cylinder                             = RightCylinder,
                cylinderSpecified                    = true,
                cylinderAxis                         = RightCylinderAxis,
                cylinderAxisSpecified                = true,
                addiction                            = RightAddiction,
                addictionSpecified                   = true,
                horizontalDiameter                   = 70,
                horizontalDiameterSpecified          = true,
                verticalDiameter                     = 70,
                verticalDiameterSpecified            = true,
                refractiveIndex                      = RefractionIndex.Value,
                refractiveIndexSpecified             = true,
                toolRealBase                         = RightToolRealBase,
                toolRealBaseSpecified                = true,
                toolIndex                            = 1.498,
                toolIndexSpecified                   = true,
                prescriptedPrism                     = 0,
                prescriptedPrismSpecified            = true,
                prescriptedPrismBase                 = 0,
                prescriptedPrismBaseSpecified        = true,
                secondaryPrism                       = 0,
                secondaryPrismSpecified              = true,
                secondaryPrismBase                   = 0,
                secondaryPrismBaseSpecified          = true,
                minimalCentralThickness              = 2,
                minimalCentralThicknessSpecified     = true,
                minimalSideThickness                 = 2,
                minimalSideThicknessSpecified        = true,
                horizontalDecentralization           = 0,
                horizontalDecentralizationSpecified  = true,
                verticalDecentralization             = 0,
                verticalDecentralizationSpecified    = true,
                monocularCentrationDistance          = 32,
                monocularCentrationDistanceSpecified = true,
                inset          = 2.2,
                insetSpecified = true
            };

            computeLensResponseDTO response = await Task.Run(() => computeSoapClient.computeLens(request)) as computeLensResponseDTO;

            if (!(response is null))
            {
                ResponseComputed.Invoke(this, Tuple.Create(request, response));
            }

            IsBusy = false;
        }
Esempio n. 9
0
        private void Write(IDictionary <OmaParameter, string> leftParameters, IDictionary <OmaParameter, string> rightParameters, computeLensResponseDTO leftComputeLensResponse, computeLensResponseDTO rightComputeLensResponse, string leftSurfaceFilePath, string rightSurfaceFilePath, IFilePathOmaBuilder filePathBuilder)
        {
            string tmpPath = Path.Combine(OutputFolder, (leftParameters is object?leftParameters: rightParameters)[OmaParameter.JOB]);

            using (StreamWriter streamWriter = File.AppendText(tmpPath))
            {
                streamWriter.WriteLine("REQ=LMS");
                streamWriter.WriteLine("JOB=" + (leftParameters is object?leftParameters: rightParameters)[OmaParameter.JOB]);
                streamWriter.WriteLine("DO=" + (leftParameters is object?leftParameters: rightParameters)[OmaParameter.DO]);

                double rightCentralThickness = rightComputeLensResponse is object?rightComputeLensResponse.value.finishedCenterThickness : 0D;
                double leftCentralThickness  = leftComputeLensResponse is object?leftComputeLensResponse.value.finishedCenterThickness : 0D;
                streamWriter.WriteLine("CTHICK=" + (rightComputeLensResponse is object?rightCentralThickness.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftCentralThickness.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("GTHK=" + (rightComputeLensResponse is object?rightCentralThickness.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftCentralThickness.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                // streamWriter.WriteLine("GTHK=" + (rightComputeLensResponse is object ? rightComputeLensResponse.value.surfaceBlockCenterGeneratorThickness.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object ? leftComputeLensResponse.value.surfaceBlockCenterGeneratorThickness.ToString("0.00", CultureInfo.InvariantCulture) : ""));

                streamWriter.WriteLine("CTHNP=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.cribPerimeterThinnestPointThickness.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.cribPerimeterThinnestPointThickness.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("CTHNA=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.cribPerimeterThinnestPointAngle.ToString() : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.cribPerimeterThinnestPointAngle.ToString() : ""));

                streamWriter.WriteLine("CTHKP=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.cribPerimeterThickestPointThickness.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.cribPerimeterThickestPointThickness.ToString("0.00", CultureInfo.InvariantCulture) : ""));

                streamWriter.WriteLine("CTHKA=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.cribPerimeterThickestPointAngle.ToString() : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.cribPerimeterThickestPointAngle.ToString() : ""));

                streamWriter.WriteLine("LAPBASX=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.lapBaseCurve.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.lapBaseCurve.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("LAPCRSX=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.lapCrossCurve.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.lapCrossCurve.ToString("0.00", CultureInfo.InvariantCulture) : ""));

                streamWriter.WriteLine("CRIB=" + (rightParameters is object?rightParameters[OmaParameter.CRIB] : "") + ";" + (leftParameters is object?leftParameters[OmaParameter.CRIB] : ""));
                streamWriter.WriteLine("ELLH=" + (rightParameters is object?rightParameters[OmaParameter.ELLH] : "") + ";" + (leftParameters is object?leftParameters[OmaParameter.ELLH] : ""));

                streamWriter.WriteLine("LDDRSPH=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedDistanceReferencePointSpherePower.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedDistanceReferencePointSpherePower.ToString("0.00", CultureInfo.InvariantCulture) : ""));

                streamWriter.WriteLine("LDDRCYL=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedDistanceReferencePointCylinderPower.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedDistanceReferencePointCylinderPower.ToString("0.00", CultureInfo.InvariantCulture) : ""));

                streamWriter.WriteLine("LDDRAX=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedLayoutReferencePointCylinderAxis.ToString() : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedLayoutReferencePointCylinderAxis.ToString() : ""));

                streamWriter.WriteLine("LDNRSPH=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedNearReferencePointSpherePower.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedNearReferencePointSpherePower.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("LDNRCYL=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedNearReferencePointCylinderPower.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedNearReferencePointCylinderPower.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("LDNRAX=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedNearReferencePointCylinderAxis.ToString() : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedNearReferencePointCylinderAxis.ToString() : ""));

                streamWriter.WriteLine("LDADD=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedAdditionPower.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedAdditionPower.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("LDSGSPH=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedLayoutReferencePointSpherePower.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedLayoutReferencePointSpherePower.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("LDSGCYL=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedLayoutReferencePointCylinderPower.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedLayoutReferencePointCylinderPower.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("LDSGAX=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedNearReferencePointCylinderAxis.ToString() : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedNearReferencePointCylinderAxis.ToString() : ""));

                streamWriter.WriteLine("LDPRVM=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedPrismMagnitude.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedPrismMagnitude.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("LDPRVA=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.designedPrismBaseSetting.ToString() : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.designedPrismBaseSetting.ToString() : ""));

                string R_BCERIN = rightParameters is object?rightParameters.ContainsKey(OmaParameter.SMOCIN) ? rightParameters[OmaParameter.SMOCIN] : rightParameters.ContainsKey(OmaParameter.BCERIN) ? rightParameters[OmaParameter.BCERIN] == "?" ? "0" : rightParameters[OmaParameter.BCERIN] : null : null;

                string L_BCERIN = leftParameters is object?leftParameters.ContainsKey(OmaParameter.SMOCIN) ? leftParameters[OmaParameter.SMOCIN] : leftParameters.ContainsKey(OmaParameter.BCERIN) ? leftParameters[OmaParameter.BCERIN] == "?" ? "0" : leftParameters[OmaParameter.BCERIN] : null : null;

                string R_BCERUP = rightParameters is object?rightParameters.ContainsKey(OmaParameter.SMOCUP) ? rightParameters[OmaParameter.SMOCUP] : rightParameters.ContainsKey(OmaParameter.BCERUP) ? rightParameters[OmaParameter.BCERUP] == "?" ? "0" : rightParameters[OmaParameter.BCERUP] : null : null;

                string L_BCERUP = leftParameters is object?leftParameters.ContainsKey(OmaParameter.SMOCUP) ? leftParameters[OmaParameter.SMOCUP] : leftParameters.ContainsKey(OmaParameter.BCERUP) ? leftParameters[OmaParameter.BCERUP] == "?" ? "0" : leftParameters[OmaParameter.BCERUP] : null : null;

                if (R_BCERIN is object || L_BCERIN is object)
                {
                    streamWriter.WriteLine("BCERIN=" + R_BCERIN + ";" + L_BCERIN);
                }
                if (R_BCERUP is object || L_BCERUP is object)
                {
                    streamWriter.WriteLine("BCERUP=" + R_BCERUP + ";" + L_BCERUP);
                }
                if (!string.IsNullOrWhiteSpace(Gax))
                {
                    streamWriter.WriteLine("GAX=" + (
                                               rightComputeLensResponse is object?
                                               Gax: ""
                                               ) + ';' + (
                                               leftComputeLensResponse is object?Gax: ""));
                }
                if (!string.IsNullOrWhiteSpace(LapGax))
                {
                    streamWriter.WriteLine("LAPGAX=" + (
                                               rightComputeLensResponse is object?
                                               LapGax: ""
                                               ) + ';' + (
                                               leftComputeLensResponse is object?LapGax: ""));
                }

                streamWriter.WriteLine("KPRVM=" + "0" + ";" + "0");

                streamWriter.WriteLine("INSET=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.inset.ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.inset.ToString("0.00", CultureInfo.InvariantCulture) : ""));
                streamWriter.WriteLine("_DOWNSET=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.downset.ToString() : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.downset.ToString() : ""));
                streamWriter.WriteLine("_FCRSSY=" + (rightComputeLensResponse is object?rightComputeLensResponse.value.crossPosition.ToString() : "") + ";" + (leftComputeLensResponse is object?leftComputeLensResponse.value.crossPosition.ToString() : ""));
                streamWriter.WriteLine("LDPATH=" + filePathBuilder.BuildFilePath());

                // RENDERE CONFIGURABILE/OPZIONALE LA RESTITUZIONE DI SVAL AVAL
                // streamWriter.WriteLine("SVAL=" + (rightParameters is object ? Sval(rightParameters, rightCentralThickness).ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftParameters is object ? Sval(leftParameters, leftCentralThickness).ToString("0.00", CultureInfo.InvariantCulture) : ""));
                // streamWriter.WriteLine("AVAL=" + (rightParameters is object ? Aval(rightParameters, rightCentralThickness).ToString("0.00", CultureInfo.InvariantCulture) : "") + ";" + (leftParameters is object ? Aval(leftParameters, leftCentralThickness).ToString("0.00", CultureInfo.InvariantCulture) : ""));

                streamWriter.WriteLine("STATUS=" + "0");
            }

            string filePath = Path.ChangeExtension(tmpPath, ".lms");

            File.Delete(filePath);
            if (File.Exists(tmpPath))
            {
                File.Move(tmpPath, filePath);
            }
        }
Esempio n. 10
0
 public void Write(OmaReaderDoubleResult OmaReaderDoubleResult, computeLensResponseDTO leftComputeLensResponse, computeLensResponseDTO rightComputeLensResponse, string leftSurfaceFilePath, string rightSurfaceFilePath, IFilePathOmaBuilder filePathBuilder)
 {
     Write(OmaReaderDoubleResult.Left, OmaReaderDoubleResult.Right, leftComputeLensResponse, rightComputeLensResponse, leftSurfaceFilePath, rightSurfaceFilePath, filePathBuilder);
 }