aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/PPC/Modules/Tango.PPC.Jobs/Dialogs/FineTuningPaletteViewVM.cs
blob: 2e16ac747efcfbe970e2ea2a53f1078693c8ad2e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.Entities;
using Tango.ColorConversion;
using Tango.PPC.Common.Models;
using Tango.SharedUI;

namespace Tango.PPC.Jobs.Dialogs
{
    /// <summary>
    /// Represents the fine tuning pallet dialog ViewModel.
    /// </summary>
    /// <seealso cref="Tango.SharedUI.DialogViewVM" />
    public class FineTuningPaletteViewVM : DialogViewVM
    {
        private Job _job;
        private bool _prevent_change;
        private IColorConverter _converter;

        private List<ColorConversionSuggestion> _suggestions;
        /// <summary>
        /// Gets or sets the triplet suggestions.
        /// </summary>
        public List<ColorConversionSuggestion> Suggestions
        {
            get { return _suggestions; }
            set { _suggestions = value; RaisePropertyChangedAuto(); }
        }

        private List<ColorConversionSuggestion> _hiveSuggestions;
        /// <summary>
        /// Gets or sets the hive suggestions.
        /// </summary>
        public List<ColorConversionSuggestion> HiveSuggestions
        {
            get { return _hiveSuggestions; }
            set { _hiveSuggestions = value; RaisePropertyChangedAuto(); }
        }

        private ColorConversionSuggestion _selectedHiveSuggestion;
        /// <summary>
        /// Gets or sets the selected hive suggestion.
        /// </summary>
        public ColorConversionSuggestion SelectedHiveSuggestion
        {
            get { return _selectedHiveSuggestion; }
            set { _selectedHiveSuggestion = value; RaisePropertyChangedAuto(); OnSelectedHiveSuggestionChanged(); }
        }

        private ColorConversionSuggestion _selectedSuggestion;
        /// <summary>
        /// Gets or sets the selected triplet suggestion.
        /// </summary>
        public ColorConversionSuggestion SelectedSuggestion
        {
            get { return _selectedSuggestion; }
            set { _selectedSuggestion = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FineTuningPaletteViewVM"/> class.
        /// </summary>
        public FineTuningPaletteViewVM()
        {
            Suggestions = new List<ColorConversionSuggestion>();
            HiveSuggestions = new List<ColorConversionSuggestion>();

            _converter = new DefaultColorConverter();
        }

        /// <summary>
        /// Called when the selected hive suggestion has been changed
        /// </summary>
        private void OnSelectedHiveSuggestionChanged()
        {
            if (!_prevent_change)
            {
                Suggestions = _converter.Convert(_job, SelectedHiveSuggestion.Color, true).CreateTrippletSuggestions();
                SelectedSuggestion = Suggestions.GetCenterSuggestion();
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FineTuningPaletteViewVM"/> class.
        /// </summary>
        /// <param name="fineTuneItem">The fine tune item.</param>
        /// <param name="job">The job.</param>
        public FineTuningPaletteViewVM(FineTuneItem fineTuneItem, Job job) : this()
        {
            _prevent_change = true;
            _job = job;
            Suggestions = fineTuneItem.Suggestions;
            HiveSuggestions = fineTuneItem.HiveSuggestions;
            SelectedHiveSuggestion = HiveSuggestions.GetCenterSuggestion();
            SelectedSuggestion = Suggestions[Suggestions.Count / 2];
            _prevent_change = false;
        }
    }
}
an>>::value ? NumTraits<RealScalar>::dummy_precision()*10 : NumTraits<RealScalar>::dummy_precision()/10; Index size = v.size(); if(size<20) return; for (int i=0; i<size; ++i) { if(i<5 || i>size-6) { Scalar ref = (low*RealScalar(size-i-1))/RealScalar(size-1) + (high*RealScalar(i))/RealScalar(size-1); if(std::abs(ref)>1) { if(!internal::isApprox(v(i), ref, prec)) std::cout << v(i) << " != " << ref << " ; relative error: " << std::abs((v(i)-ref)/ref) << " ; required precision: " << prec << " ; range: " << low << "," << high << " ; i: " << i << "\n"; VERIFY(internal::isApprox(v(i), (low*RealScalar(size-i-1))/RealScalar(size-1) + (high*RealScalar(i))/RealScalar(size-1), prec)); } } } } template<typename VectorType> void testVectorType(const VectorType& base) { typedef typename VectorType::Scalar Scalar; typedef typename VectorType::RealScalar RealScalar; const Index size = base.size(); Scalar high = internal::random<Scalar>(-500,500); Scalar low = (size == 1 ? high : internal::random<Scalar>(-500,500)); if (low>high) std::swap(low,high); // check low==high if(internal::random<float>(0.f,1.f)<0.05f) low = high; // check abs(low) >> abs(high) else if(size>2 && std::numeric_limits<RealScalar>::max_exponent10>0 && internal::random<float>(0.f,1.f)<0.1f) low = -internal::random<Scalar>(1,2) * RealScalar(std::pow(RealScalar(10),std::numeric_limits<RealScalar>::max_exponent10/2)); const Scalar step = ((size == 1) ? 1 : (high-low)/(size-1)); // check whether the result yields what we expect it to do VectorType m(base); m.setLinSpaced(size,low,high); if(!NumTraits<Scalar>::IsInteger) { VectorType n(size); for (int i=0; i<size; ++i) n(i) = low+i*step; VERIFY_IS_APPROX(m,n); CALL_SUBTEST( check_extremity_accuracy(m, low, high) ); } if((!NumTraits<Scalar>::IsInteger) || ((high-low)>=size && (Index(high-low)%(size-1))==0) || (Index(high-low+1)<size && (size%Index(high-low+1))==0)) { VectorType n(size); if((!NumTraits<Scalar>::IsInteger) || (high-low>=size)) for (int i=0; i<size; ++i) n(i) = size==1 ? low : (low + ((high-low)*Scalar(i))/(size-1)); else for (int i=0; i<size; ++i) n(i) = size==1 ? low : low + Scalar((double(high-low+1)*double(i))/double(size)); VERIFY_IS_APPROX(m,n); // random access version m = VectorType::LinSpaced(size,low,high); VERIFY_IS_APPROX(m,n); VERIFY( internal::isApprox(m(m.size()-1),high) ); VERIFY( size==1 || internal::isApprox(m(0),low) ); VERIFY_IS_EQUAL(m(m.size()-1) , high); if(!NumTraits<Scalar>::IsInteger) CALL_SUBTEST( check_extremity_accuracy(m, low, high) ); } VERIFY( m(m.size()-1) <= high ); VERIFY( (m.array() <= high).all() ); VERIFY( (m.array() >= low).all() ); VERIFY( m(m.size()-1) >= low ); if(size>=1) { VERIFY( internal::isApprox(m(0),low) ); VERIFY_IS_EQUAL(m(0) , low); } // check whether everything works with row and col major vectors Matrix<Scalar,Dynamic,1> row_vector(size); Matrix<Scalar,1,Dynamic> col_vector(size); row_vector.setLinSpaced(size,low,high); col_vector.setLinSpaced(size,low,high); // when using the extended precision (e.g., FPU) the relative error might exceed 1 bit // when computing the squared sum in isApprox, thus the 2x factor. VERIFY( row_vector.isApprox(col_vector.transpose(), Scalar(2)*NumTraits<Scalar>::epsilon())); Matrix<Scalar,Dynamic,1> size_changer(size+50); size_changer.setLinSpaced(size,low,high); VERIFY( size_changer.size() == size ); typedef Matrix<Scalar,1,1> ScalarMatrix; ScalarMatrix scalar; scalar.setLinSpaced(1,low,high); VERIFY_IS_APPROX( scalar, ScalarMatrix::Constant(high) ); VERIFY_IS_APPROX( ScalarMatrix::LinSpaced(1,low,high), ScalarMatrix::Constant(high) ); // regression test for bug 526 (linear vectorized transversal) if (size > 1 && (!NumTraits<Scalar>::IsInteger)) { m.tail(size-1).setLinSpaced(low, high); VERIFY_IS_APPROX(m(size-1), high); } // regression test for bug 1383 (LinSpaced with empty size/range) { Index n0 = VectorType::SizeAtCompileTime==Dynamic ? 0 : VectorType::SizeAtCompileTime; low = internal::random<Scalar>(); m = VectorType::LinSpaced(n0,low,low-1); VERIFY(m.size()==n0); if(VectorType::SizeAtCompileTime==Dynamic) { VERIFY_IS_EQUAL(VectorType::LinSpaced(n0,0,Scalar(n0-1)).sum(),Scalar(0)); VERIFY_IS_EQUAL(VectorType::LinSpaced(n0,low,low-1).sum(),Scalar(0)); } m.setLinSpaced(n0,0,Scalar(n0-1)); VERIFY(m.size()==n0); m.setLinSpaced(n0,low,low-1); VERIFY(m.size()==n0); // empty range only: VERIFY_IS_APPROX(VectorType::LinSpaced(size,low,low),VectorType::Constant(size,low)); m.setLinSpaced(size,low,low); VERIFY_IS_APPROX(m,VectorType::Constant(size,low)); if(NumTraits<Scalar>::IsInteger) { VERIFY_IS_APPROX( VectorType::LinSpaced(size,low,Scalar(low+size-1)), VectorType::LinSpaced(size,Scalar(low+size-1),low).reverse() ); if(VectorType::SizeAtCompileTime==Dynamic) { // Check negative multiplicator path: for(Index k=1; k<5; ++k) VERIFY_IS_APPROX( VectorType::LinSpaced(size,low,Scalar(low+(size-1)*k)), VectorType::LinSpaced(size,Scalar(low+(size-1)*k),low).reverse() ); // Check negative divisor path: for(Index k=1; k<5; ++k) VERIFY_IS_APPROX( VectorType::LinSpaced(size*k,low,Scalar(low+size-1)), VectorType::LinSpaced(size*k,Scalar(low+size-1),low).reverse() ); } } } } template<typename MatrixType> void testMatrixType(const MatrixType& m) { using std::abs; const Index rows = m.rows(); const Index cols = m.cols(); typedef typename MatrixType::Scalar Scalar; typedef typename MatrixType::RealScalar RealScalar; Scalar s1; do { s1 = internal::random<Scalar>(); } while(abs(s1)<RealScalar(1e-5) && (!NumTraits<Scalar>::IsInteger)); MatrixType A; A.setIdentity(rows, cols); VERIFY(equalsIdentity(A)); VERIFY(equalsIdentity(MatrixType::Identity(rows, cols))); A = MatrixType::Constant(rows,cols,s1); Index i = internal::random<Index>(0,rows-1); Index j = internal::random<Index>(0,cols-1); VERIFY_IS_APPROX( MatrixType::Constant(rows,cols,s1)(i,j), s1 ); VERIFY_IS_APPROX( MatrixType::Constant(rows,cols,s1).coeff(i,j), s1 ); VERIFY_IS_APPROX( A(i,j), s1 ); } void test_nullary() { CALL_SUBTEST_1( testMatrixType(Matrix2d()) ); CALL_SUBTEST_2( testMatrixType(MatrixXcf(internal::random<int>(1,300),internal::random<int>(1,300))) ); CALL_SUBTEST_3( testMatrixType(MatrixXf(internal::random<int>(1,300),internal::random<int>(1,300))) ); for(int i = 0; i < g_repeat*10; i++) { CALL_SUBTEST_4( testVectorType(VectorXd(internal::random<int>(1,30000))) ); CALL_SUBTEST_5( testVectorType(Vector4d()) ); // regression test for bug 232 CALL_SUBTEST_6( testVectorType(Vector3d()) ); CALL_SUBTEST_7( testVectorType(VectorXf(internal::random<int>(1,30000))) ); CALL_SUBTEST_8( testVectorType(Vector3f()) ); CALL_SUBTEST_8( testVectorType(Vector4f()) ); CALL_SUBTEST_8( testVectorType(Matrix<float,8,1>()) ); CALL_SUBTEST_8( testVectorType(Matrix<float,1,1>()) ); CALL_SUBTEST_9( testVectorType(VectorXi(internal::random<int>(1,10))) ); CALL_SUBTEST_9( testVectorType(VectorXi(internal::random<int>(9,300))) ); CALL_SUBTEST_9( testVectorType(Matrix<int,1,1>()) ); } #ifdef EIGEN_TEST_PART_6 // Assignment of a RowVectorXd to a MatrixXd (regression test for bug #79). VERIFY( (MatrixXd(RowVectorXd::LinSpaced(3, 0, 1)) - RowVector3d(0, 0.5, 1)).norm() < std::numeric_limits<double>::epsilon() ); #endif #ifdef EIGEN_TEST_PART_9 // Check possible overflow issue { int n = 60000; ArrayXi a1(n), a2(n); a1.setLinSpaced(n, 0, n-1); for(int i=0; i<n; ++i) a2(i) = i; VERIFY_IS_APPROX(a1,a2); } #endif #ifdef EIGEN_TEST_PART_10 // check some internal logic VERIFY(( internal::has_nullary_operator<internal::scalar_constant_op<double> >::value )); VERIFY(( !internal::has_unary_operator<internal::scalar_constant_op<double> >::value )); VERIFY(( !internal::has_binary_operator<internal::scalar_constant_op<double> >::value )); VERIFY(( internal::functor_has_linear_access<internal::scalar_constant_op<double> >::ret )); VERIFY(( !internal::has_nullary_operator<internal::scalar_identity_op<double> >::value )); VERIFY(( !internal::has_unary_operator<internal::scalar_identity_op<double> >::value )); VERIFY(( internal::has_binary_operator<internal::scalar_identity_op<double> >::value )); VERIFY(( !internal::functor_has_linear_access<internal::scalar_identity_op<double> >::ret )); VERIFY(( !internal::has_nullary_operator<internal::linspaced_op<float,float> >::value )); VERIFY(( internal::has_unary_operator<internal::linspaced_op<float,float> >::value )); VERIFY(( !internal::has_binary_operator<internal::linspaced_op<float,float> >::value )); VERIFY(( internal::functor_has_linear_access<internal::linspaced_op<float,float> >::ret )); // Regression unit test for a weird MSVC bug. // Search "nullary_wrapper_workaround_msvc" in CoreEvaluators.h for the details. // See also traits<Ref>::match. { MatrixXf A = MatrixXf::Random(3,3); Ref<const MatrixXf> R = 2.0*A; VERIFY_IS_APPROX(R, A+A); Ref<const MatrixXf> R1 = MatrixXf::Random(3,3)+A; VectorXi V = VectorXi::Random(3); Ref<const VectorXi> R2 = VectorXi::LinSpaced(3,1,3)+V; VERIFY_IS_APPROX(R2, V+Vector3i(1,2,3)); VERIFY(( internal::has_nullary_operator<internal::scalar_constant_op<float> >::value )); VERIFY(( !internal::has_unary_operator<internal::scalar_constant_op<float> >::value )); VERIFY(( !internal::has_binary_operator<internal::scalar_constant_op<float> >::value )); VERIFY(( internal::functor_has_linear_access<internal::scalar_constant_op<float> >::ret )); VERIFY(( !internal::has_nullary_operator<internal::linspaced_op<int,int> >::value )); VERIFY(( internal::has_unary_operator<internal::linspaced_op<int,int> >::value )); VERIFY(( !internal::has_binary_operator<internal::linspaced_op<int,int> >::value )); VERIFY(( internal::functor_has_linear_access<internal::linspaced_op<int,int> >::ret )); } #endif }