Mercurial > hg > orthanc-stone

comparison UnitTestsSources/UnitTestsMain.cpp @ 1172:6def5bfba867 broker

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fix unit tests
author Sebastien Jodogne <s.jodogne@gmail.com>
date Wed, 20 Nov 2019 13:13:53 +0100
parents 1644de437a7b
children c3d219b6266b
comparison
equal deleted inserted replaced
1171:ba08f2b0a779 1172:6def5bfba867
565 ASSERT_NEAR( 9.18901e-05, p(2,2), 0.0000000001); 565 ASSERT_NEAR( 9.18901e-05, p(2,2), 0.0000000001);
566 ASSERT_NEAR( 1, p(2,3), 0.0000001); 566 ASSERT_NEAR( 1, p(2,3), 0.0000001);
567 } 567 }
568 568
569 569
570 static bool IsEqualVector(OrthancStone::Vector a, 570 static bool IsEqualRotationVector(OrthancStone::Vector a,
571 OrthancStone::Vector b) 571 OrthancStone::Vector b)
572 {
573 if (a.size() != b.size() ||
574 a.size() != 3)
575 {
576 return false;
577 }
578 else
579 {
580 OrthancStone::LinearAlgebra::NormalizeVector(a);
581 OrthancStone::LinearAlgebra::NormalizeVector(b);
582 return OrthancStone::LinearAlgebra::IsCloseToZero(boost::numeric::ublas::norm_2(a - b));
583 }
584 }
585
586
587 TEST(GeometryToolbox, AlignVectorsWithRotation)
588 {
589 OrthancStone::Vector a, b;
590 OrthancStone::Matrix r;
591
592 OrthancStone::LinearAlgebra::AssignVector(a, -200, 200, -846.63);
593 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
594
595 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
596 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
597 ASSERT_TRUE(IsEqualRotationVector(OrthancStone::LinearAlgebra::Product(r, a), b));
598
599 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, b, a);
600 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
601 ASSERT_TRUE(IsEqualRotationVector(OrthancStone::LinearAlgebra::Product(r, b), a));
602
603 OrthancStone::LinearAlgebra::AssignVector(a, 1, 0, 0);
604 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
605 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
606 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
607 ASSERT_TRUE(IsEqualRotationVector(OrthancStone::LinearAlgebra::Product(r, a), b));
608
609 OrthancStone::LinearAlgebra::AssignVector(a, 0, 1, 0);
610 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
611 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
612 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
613 ASSERT_TRUE(IsEqualRotationVector(OrthancStone::LinearAlgebra::Product(r, a), b));
614
615 OrthancStone::LinearAlgebra::AssignVector(a, 0, 0, 1);
616 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
617 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
618 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
619 ASSERT_TRUE(IsEqualRotationVector(OrthancStone::LinearAlgebra::Product(r, a), b));
620
621 OrthancStone::LinearAlgebra::AssignVector(a, 0, 0, 0);
622 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
623 ASSERT_THROW(OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b), Orthanc::OrthancException);
624
625 // TODO: Deal with opposite vectors
626
627 /*
628 OrthancStone::LinearAlgebra::AssignVector(a, 0, 0, -1);
629 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
630 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
631 OrthancStone::LinearAlgebra::Print(r);
632 OrthancStone::LinearAlgebra::Print(boost::numeric::ublas::prod(r, a));
633 */
634 }
635
636 TEST(MessagingToolbox, ParseJson)
637 {
638 Json::Value response;
639 std::string source = "{\"command\":\"panel:takeDarkImage\",\"commandType\":\"simple\",\"args\":{}}";
640 ASSERT_TRUE(Deprecated::MessagingToolbox::ParseJson(response, source.c_str(), source.size()));
641 }
642
643
644
645 static bool IsEqualVectorL1(OrthancStone::Vector a,
646 OrthancStone::Vector b)
572 { 647 {
573 if (a.size() != b.size()) 648 if (a.size() != b.size())
574 { 649 {
575 return false; 650 return false;
576 } 651 }
586 661
587 return true; 662 return true;
588 } 663 }
589 } 664 }
590 665
591
592 TEST(GeometryToolbox, AlignVectorsWithRotation)
593 {
594 OrthancStone::Vector a, b;
595 OrthancStone::Matrix r;
596
597 OrthancStone::LinearAlgebra::AssignVector(a, -200, 200, -846.63);
598 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
599
600 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
601 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
602 ASSERT_TRUE(IsEqualVector(OrthancStone::LinearAlgebra::Product(r, a), b));
603
604 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, b, a);
605 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
606 ASSERT_TRUE(IsEqualVector(OrthancStone::LinearAlgebra::Product(r, b), a));
607
608 OrthancStone::LinearAlgebra::AssignVector(a, 1, 0, 0);
609 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
610 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
611 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
612 ASSERT_TRUE(IsEqualVector(OrthancStone::LinearAlgebra::Product(r, a), b));
613
614 OrthancStone::LinearAlgebra::AssignVector(a, 0, 1, 0);
615 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
616 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
617 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
618 ASSERT_TRUE(IsEqualVector(OrthancStone::LinearAlgebra::Product(r, a), b));
619
620 OrthancStone::LinearAlgebra::AssignVector(a, 0, 0, 1);
621 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
622 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
623 ASSERT_TRUE(OrthancStone::LinearAlgebra::IsRotationMatrix(r));
624 ASSERT_TRUE(IsEqualVector(OrthancStone::LinearAlgebra::Product(r, a), b));
625
626 OrthancStone::LinearAlgebra::AssignVector(a, 0, 0, 0);
627 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
628 ASSERT_THROW(OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b), Orthanc::OrthancException);
629
630 // TODO: Deal with opposite vectors
631
632 /*
633 OrthancStone::LinearAlgebra::AssignVector(a, 0, 0, -1);
634 OrthancStone::LinearAlgebra::AssignVector(b, 0, 0, 1);
635 OrthancStone::GeometryToolbox::AlignVectorsWithRotation(r, a, b);
636 OrthancStone::LinearAlgebra::Print(r);
637 OrthancStone::LinearAlgebra::Print(boost::numeric::ublas::prod(r, a));
638 */
639 }
640
641 TEST(MessagingToolbox, ParseJson)
642 {
643 Json::Value response;
644 std::string source = "{\"command\":\"panel:takeDarkImage\",\"commandType\":\"simple\",\"args\":{}}";
645 ASSERT_TRUE(Deprecated::MessagingToolbox::ParseJson(response, source.c_str(), source.size()));
646 }
647 666
648 TEST(VolumeImageGeometry, Basic) 667 TEST(VolumeImageGeometry, Basic)
649 { 668 {
650 using namespace OrthancStone; 669 using namespace OrthancStone;
651 670
719 738
720 Vector q = (g.GetAxialGeometry().MapSliceToWorldCoordinates( 739 Vector q = (g.GetAxialGeometry().MapSliceToWorldCoordinates(
721 static_cast<double>(x) * sx, 740 static_cast<double>(x) * sx,
722 static_cast<double>(y) * sy) + 741 static_cast<double>(y) * sy) +
723 z * sz * g.GetAxialGeometry().GetNormal()); 742 z * sz * g.GetAxialGeometry().GetNormal());
724 ASSERT_TRUE(IsEqualVector(p, q)); 743 ASSERT_TRUE(IsEqualVectorL1(p, q));
725 744
726 q = (g.GetCoronalGeometry().MapSliceToWorldCoordinates( 745 q = (g.GetCoronalGeometry().MapSliceToWorldCoordinates(
727 static_cast<double>(x) * sx, 746 static_cast<double>(x) * sx,
728 static_cast<double>(g.GetDepth() - 1 - z) * sz) + 747 static_cast<double>(g.GetDepth() - 1 - z) * sz) +
729 y * sy * g.GetCoronalGeometry().GetNormal()); 748 y * sy * g.GetCoronalGeometry().GetNormal());
730 ASSERT_TRUE(IsEqualVector(p, q)); 749 ASSERT_TRUE(IsEqualVectorL1(p, q));
731 750
732 /** 751 /**
733 * WARNING: In sagittal geometry, the normal points to 752 * WARNING: In sagittal geometry, the normal points to
734 * REDUCING X-axis in the 3D world. This is necessary to keep 753 * REDUCING X-axis in the 3D world. This is necessary to keep
735 * the right-hand coordinate system. Hence the "-". 754 * the right-hand coordinate system. Hence the "-".
736 **/ 755 **/
737 q = (g.GetSagittalGeometry().MapSliceToWorldCoordinates( 756 q = (g.GetSagittalGeometry().MapSliceToWorldCoordinates(
738 static_cast<double>(y) * sy, 757 static_cast<double>(y) * sy,
739 static_cast<double>(g.GetDepth() - 1 - z) * sz) + 758 static_cast<double>(g.GetDepth() - 1 - z) * sz) +
740 x * sx * (-g.GetSagittalGeometry().GetNormal())); 759 x * sx * (-g.GetSagittalGeometry().GetNormal()));
741 ASSERT_TRUE(IsEqualVector(p, q)); 760 ASSERT_TRUE(IsEqualVectorL1(p, q));
742 } 761 }
743 } 762 }
744 } 763 }
745 764
746 ASSERT_EQ(0, (int) VolumeProjection_Axial); 765 ASSERT_EQ(0, (int) VolumeProjection_Axial);
758 { 777 {
759 CoordinateSystem3D plane = g.GetProjectionSlice(projection, i); 778 CoordinateSystem3D plane = g.GetProjectionSlice(projection, i);
760 779
761 if (projection == VolumeProjection_Sagittal) 780 if (projection == VolumeProjection_Sagittal)
762 { 781 {
763 ASSERT_TRUE(IsEqualVector(plane.GetOrigin(), s.GetOrigin() + static_cast<double>(i) * 782 ASSERT_TRUE(IsEqualVectorL1(plane.GetOrigin(), s.GetOrigin() + static_cast<double>(i) *
764 (-s.GetNormal()) * g.GetVoxelDimensions(projection)[2])); 783 (-s.GetNormal()) * g.GetVoxelDimensions(projection)[2]));
765 } 784 }
766 else 785 else
767 { 786 {
768 ASSERT_TRUE(IsEqualVector(plane.GetOrigin(), s.GetOrigin() + static_cast<double>(i) * 787 ASSERT_TRUE(IsEqualVectorL1(plane.GetOrigin(), s.GetOrigin() + static_cast<double>(i) *
769 s.GetNormal() * g.GetVoxelDimensions(projection)[2])); 788 s.GetNormal() * g.GetVoxelDimensions(projection)[2]));
770 } 789 }
771 790
772 ASSERT_TRUE(IsEqualVector(plane.GetAxisX(), s.GetAxisX())); 791 ASSERT_TRUE(IsEqualVectorL1(plane.GetAxisX(), s.GetAxisX()));
773 ASSERT_TRUE(IsEqualVector(plane.GetAxisY(), s.GetAxisY())); 792 ASSERT_TRUE(IsEqualVectorL1(plane.GetAxisY(), s.GetAxisY()));
774 793
775 unsigned int slice; 794 unsigned int slice;
776 VolumeProjection q; 795 VolumeProjection q;
777 ASSERT_TRUE(g.DetectSlice(q, slice, plane)); 796 ASSERT_TRUE(g.DetectSlice(q, slice, plane));
778 ASSERT_EQ(projection, q); 797 ASSERT_EQ(projection, q);