diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3d47f986c41db29ec6dc0d5036bf760b3a1cf366
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+.idea/
+target/
+.settings/
+*.iml
+.project
+.classpath
\ No newline at end of file
diff --git a/bin/plugins/ragini/voronoidiagram/AFL.class b/bin/plugins/ragini/voronoidiagram/AFL.class
new file mode 100644
index 0000000000000000000000000000000000000000..989d4691c65c3279dcb854c503057a592473b752
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/AFL.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..3fa201a1ee4b983ff3665119989790163bbd6443
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$10.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$10.class
new file mode 100644
index 0000000000000000000000000000000000000000..e171e11efc9ef3db5fbcc1e64442716bcb944143
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$10.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$11.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$11.class
new file mode 100644
index 0000000000000000000000000000000000000000..7c0bf72d7663399e5766c8e09b108f0455bab972
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$11.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$12.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$12.class
new file mode 100644
index 0000000000000000000000000000000000000000..8b43be3ca242f5af5ef9c72b83567facfaabe3a2
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$12.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$13.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$13.class
new file mode 100644
index 0000000000000000000000000000000000000000..3133c95dc94c305fdcf59f9e497f7476afbbd49d
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$13.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$14.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$14.class
new file mode 100644
index 0000000000000000000000000000000000000000..4b4e7266214ed26a13e0f74c92fa286809176f9a
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$14.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$15.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$15.class
new file mode 100644
index 0000000000000000000000000000000000000000..712d23ccc8087045869f7113cf18f294513853f8
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$15.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$16.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$16.class
new file mode 100644
index 0000000000000000000000000000000000000000..934c533a69c1307252e8f569bf2ef7a8ddbe877d
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$16.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$17.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$17.class
new file mode 100644
index 0000000000000000000000000000000000000000..e12466982f50a5b5afd1ad6eaa64342b5b16a9d7
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$17.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$18.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$18.class
new file mode 100644
index 0000000000000000000000000000000000000000..b3db3f378cbf38197507858cc090b5390dc2a6af
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$18.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$19.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$19.class
new file mode 100644
index 0000000000000000000000000000000000000000..a4af60edd89571bb73a98ea1f328206f07b3448f
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$19.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener.class
new file mode 100644
index 0000000000000000000000000000000000000000..8dc50f643c2b5eb6a1e7f7e2a55cd4b531ee7e10
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener1.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener1.class
new file mode 100644
index 0000000000000000000000000000000000000000..deaa13cc9f92d99ce8824bac6ca0d62210ac88a5
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener1.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener2.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener2.class
new file mode 100644
index 0000000000000000000000000000000000000000..88635cec7878341965a8a58c639715b5e85587c0
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener2.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener3.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener3.class
new file mode 100644
index 0000000000000000000000000000000000000000..0652ecc878ae7cb2aeb517f8ead1ebe1038e7a54
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListener3.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListenerBin.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListenerBin.class
new file mode 100644
index 0000000000000000000000000000000000000000..a2b640f5936864c1bb3427eba7e093db823ff619
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListenerBin.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListenerTb.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListenerTb.class
new file mode 100644
index 0000000000000000000000000000000000000000..49e46e1d837b857cceb2c0fa44e186e2c7090bff
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$1_cls1SelectItemListenerTb.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$2.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$2.class
new file mode 100644
index 0000000000000000000000000000000000000000..290a6c10e0e677067683678d65b90c01248bd3d5
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$2.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$20.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$20.class
new file mode 100644
index 0000000000000000000000000000000000000000..a445b9734bcadd123f3b03d5cc59c122bf2c380b
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$20.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$21.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$21.class
new file mode 100644
index 0000000000000000000000000000000000000000..6a74d34b4e94733a28b6ee1f1b5f53c0f7db6dd7
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$21.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$22.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$22.class
new file mode 100644
index 0000000000000000000000000000000000000000..8fcf286fb316d7291f5fefb44851e24540f5f4c7
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$22.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$23.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$23.class
new file mode 100644
index 0000000000000000000000000000000000000000..07e6f0fab069306afc9e0d61aa30ffb4388da980
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$23.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$3.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$3.class
new file mode 100644
index 0000000000000000000000000000000000000000..50b4b8ddf4989d5560f1507b4b53692ccbb40939
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$3.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$4.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$4.class
new file mode 100644
index 0000000000000000000000000000000000000000..52225bd77375589e5513ea169ceddcb1a6bd2ddf
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$4.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$5.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$5.class
new file mode 100644
index 0000000000000000000000000000000000000000..04b24d48c4b08d60dd9a55ad3e2a500a7bd9d35e
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$5.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$6.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$6.class
new file mode 100644
index 0000000000000000000000000000000000000000..32740095bae204d92995a492a4972897b38c278a
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$6.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$7.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$7.class
new file mode 100644
index 0000000000000000000000000000000000000000..58c9608b78359c4c42220f28c8b4b24795efe6d1
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$7.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$8.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$8.class
new file mode 100644
index 0000000000000000000000000000000000000000..b45ff48a146937ea1d15d5a4c411989488bc3863
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$8.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph$9.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$9.class
new file mode 100644
index 0000000000000000000000000000000000000000..19f6b2deb0ee9bd7278fb8f87f8918651bc976f1
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph$9.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Alpha_Morph.class b/bin/plugins/ragini/voronoidiagram/Alpha_Morph.class
new file mode 100644
index 0000000000000000000000000000000000000000..6edffeaf06b24725ebdc5e662ea153826f521a81
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Alpha_Morph.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Arcs.class b/bin/plugins/ragini/voronoidiagram/Arcs.class
new file mode 100644
index 0000000000000000000000000000000000000000..307641af20c256758b072c14c519e1d60080f8ad
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Arcs.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/ArraySetter.class b/bin/plugins/ragini/voronoidiagram/ArraySetter.class
new file mode 100644
index 0000000000000000000000000000000000000000..6b677eba32f1f4193cb353bc73564d3f7360f9de
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/ArraySetter.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Circ.class b/bin/plugins/ragini/voronoidiagram/Circ.class
new file mode 100644
index 0000000000000000000000000000000000000000..c2312a1e68a0c6354b93e0fb61c80cacc54d925e
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Circ.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Constants.class b/bin/plugins/ragini/voronoidiagram/Constants.class
new file mode 100644
index 0000000000000000000000000000000000000000..1279d5f25e0fd2766cfd48ed7b195f3bbb58a327
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Constants.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/DT.class b/bin/plugins/ragini/voronoidiagram/DT.class
new file mode 100644
index 0000000000000000000000000000000000000000..277611b217a50d0d03f09547511c7ad1040d8b6e
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/DT.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Delaunay.class b/bin/plugins/ragini/voronoidiagram/Delaunay.class
new file mode 100644
index 0000000000000000000000000000000000000000..d9af3f1ec9d354cd6c824b7c6b49c94568ec7022
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Delaunay.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/DelaunayTriangulator.class b/bin/plugins/ragini/voronoidiagram/DelaunayTriangulator.class
new file mode 100644
index 0000000000000000000000000000000000000000..4163004f3d2b97e4d7bc5b8790a19e87f83335ed
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/DelaunayTriangulator.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Display.class b/bin/plugins/ragini/voronoidiagram/Display.class
new file mode 100644
index 0000000000000000000000000000000000000000..9ebec8d416b5ae82e22b387d1cb36ffd8b5d33f5
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Display.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Edge.class b/bin/plugins/ragini/voronoidiagram/Edge.class
new file mode 100644
index 0000000000000000000000000000000000000000..4a59f403158bc8f8e2f2da5783f27e6a0409d6bd
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Edge.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/EdgeL.class b/bin/plugins/ragini/voronoidiagram/EdgeL.class
new file mode 100644
index 0000000000000000000000000000000000000000..a73b08741d43a8f827f3740ec528b640a9986879
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/EdgeL.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/EdgeList.class b/bin/plugins/ragini/voronoidiagram/EdgeList.class
new file mode 100644
index 0000000000000000000000000000000000000000..5cef6dd365bca202f99739808b30de9968ca7e78
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/EdgeList.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/EdgeRNG.class b/bin/plugins/ragini/voronoidiagram/EdgeRNG.class
new file mode 100644
index 0000000000000000000000000000000000000000..a5dca4306febbe78f6b39a7d921615af0a6282ba
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/EdgeRNG.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/EdgeS.class b/bin/plugins/ragini/voronoidiagram/EdgeS.class
new file mode 100644
index 0000000000000000000000000000000000000000..4f67acd43dc15be7d5a0b2903a8aee3fd750190b
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/EdgeS.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Face.class b/bin/plugins/ragini/voronoidiagram/Face.class
new file mode 100644
index 0000000000000000000000000000000000000000..b11f338f5949d6f467470a8410b66f54da49414e
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Face.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/FreeList.class b/bin/plugins/ragini/voronoidiagram/FreeList.class
new file mode 100644
index 0000000000000000000000000000000000000000..57e4486d12b9fa742118955e4452c84de26ff06b
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/FreeList.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/FreeNode.class b/bin/plugins/ragini/voronoidiagram/FreeNode.class
new file mode 100644
index 0000000000000000000000000000000000000000..2e9b019fa7e762589f2dacd88cd96f8e618e2e8b
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/FreeNode.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Geometry.class b/bin/plugins/ragini/voronoidiagram/Geometry.class
new file mode 100644
index 0000000000000000000000000000000000000000..bf54e943d1a038d7c077b03570586a7b074926ab
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Geometry.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/GraphD.class b/bin/plugins/ragini/voronoidiagram/GraphD.class
new file mode 100644
index 0000000000000000000000000000000000000000..40609a768209a875bf9c90847d3f80c59b1d7a85
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/GraphD.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/HalfEdge.class b/bin/plugins/ragini/voronoidiagram/HalfEdge.class
new file mode 100644
index 0000000000000000000000000000000000000000..dcad064887896b4e1d163713defd9cdb13247cd9
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/HalfEdge.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Image_Extract.class b/bin/plugins/ragini/voronoidiagram/Image_Extract.class
new file mode 100644
index 0000000000000000000000000000000000000000..9d60b372988bc1df161a4628ced24266ca37b0d5
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Image_Extract.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/IntArraySetter.class b/bin/plugins/ragini/voronoidiagram/IntArraySetter.class
new file mode 100644
index 0000000000000000000000000000000000000000..b7b0a5369a2c0635c24f818bb61eb15280578d24
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/IntArraySetter.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/IntSetter.class b/bin/plugins/ragini/voronoidiagram/IntSetter.class
new file mode 100644
index 0000000000000000000000000000000000000000..94b5db001690fac428a99fc3463a6b1067df8fe8
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/IntSetter.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/MorphologicalOperators.class b/bin/plugins/ragini/voronoidiagram/MorphologicalOperators.class
new file mode 100644
index 0000000000000000000000000000000000000000..78c6ed8dadd0e4f0c1038707ebdd81af54290031
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/MorphologicalOperators.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/NVert.class b/bin/plugins/ragini/voronoidiagram/NVert.class
new file mode 100644
index 0000000000000000000000000000000000000000..026e888a8cbeb852596fd6a7b8f5f0bc70c734d6
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/NVert.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Neighbor.class b/bin/plugins/ragini/voronoidiagram/Neighbor.class
new file mode 100644
index 0000000000000000000000000000000000000000..0cab07e90c9f969c3a44d7163863d30a10fc96a2
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Neighbor.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Point.class b/bin/plugins/ragini/voronoidiagram/Point.class
new file mode 100644
index 0000000000000000000000000000000000000000..fe7b8ccd15beee014cd5d18d6f54480c405af9f7
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Point.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/PointType.class b/bin/plugins/ragini/voronoidiagram/PointType.class
new file mode 100644
index 0000000000000000000000000000000000000000..fc562490485b940b8a39bc9df1db14682312b293
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/PointType.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/PointVor.class b/bin/plugins/ragini/voronoidiagram/PointVor.class
new file mode 100644
index 0000000000000000000000000000000000000000..d56bc8bc8c8353cd16a035149098cb9c48772176
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/PointVor.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Provider.class b/bin/plugins/ragini/voronoidiagram/Provider.class
new file mode 100644
index 0000000000000000000000000000000000000000..b44a874c497848ca81ea1305441b199da20b9cbd
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Provider.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/QuadEdge.class b/bin/plugins/ragini/voronoidiagram/QuadEdge.class
new file mode 100644
index 0000000000000000000000000000000000000000..3da8cd2047513ea55b203db1c009cea0c9263d1f
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/QuadEdge.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/ROI2DEdge.class b/bin/plugins/ragini/voronoidiagram/ROI2DEdge.class
new file mode 100644
index 0000000000000000000000000000000000000000..27fc0b9fa0d49c12f601bf6f5a5bb66d6e379b9e
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/ROI2DEdge.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/ROI2DSite.class b/bin/plugins/ragini/voronoidiagram/ROI2DSite.class
new file mode 100644
index 0000000000000000000000000000000000000000..3b0f032c71f4256707caefc61244f767fa6b0d31
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/ROI2DSite.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Setter.class b/bin/plugins/ragini/voronoidiagram/Setter.class
new file mode 100644
index 0000000000000000000000000000000000000000..700b5f57869d1d71d0e25bd53d394dc983de106f
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Setter.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Site$NeighborComp.class b/bin/plugins/ragini/voronoidiagram/Site$NeighborComp.class
new file mode 100644
index 0000000000000000000000000000000000000000..1f2fd0fcf8fba2559fe1da55ebaf538cc84aba87
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Site$NeighborComp.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Site.class b/bin/plugins/ragini/voronoidiagram/Site.class
new file mode 100644
index 0000000000000000000000000000000000000000..c157bc907b1479c17ec3d6c2e52cf5db3eac36b8
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Site.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/SiteProvider.class b/bin/plugins/ragini/voronoidiagram/SiteProvider.class
new file mode 100644
index 0000000000000000000000000000000000000000..10613b343cd2c134090f8fa285d7c67a49b927e3
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/SiteProvider.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Tri.class b/bin/plugins/ragini/voronoidiagram/Tri.class
new file mode 100644
index 0000000000000000000000000000000000000000..6056b515081fa06ee17b50d9efe112f17d7c9478
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Tri.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/UniformGrid$GridCell.class b/bin/plugins/ragini/voronoidiagram/UniformGrid$GridCell.class
new file mode 100644
index 0000000000000000000000000000000000000000..6f12abda79e085381ba5a22f9ca95a0036d955a7
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/UniformGrid$GridCell.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/UniformGrid$GridInterval.class b/bin/plugins/ragini/voronoidiagram/UniformGrid$GridInterval.class
new file mode 100644
index 0000000000000000000000000000000000000000..1930219dac50566b21736dcf3aac7b1fb944248f
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/UniformGrid$GridInterval.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/UniformGrid$GridPosition.class b/bin/plugins/ragini/voronoidiagram/UniformGrid$GridPosition.class
new file mode 100644
index 0000000000000000000000000000000000000000..43775da66cf6e98d2ad89a6ce54dcb71fbea996e
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/UniformGrid$GridPosition.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/UniformGrid$PointItem.class b/bin/plugins/ragini/voronoidiagram/UniformGrid$PointItem.class
new file mode 100644
index 0000000000000000000000000000000000000000..d8ced8706dfb9616c19021e7d52c40b84f2f722c
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/UniformGrid$PointItem.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/UniformGrid$PointIterator.class b/bin/plugins/ragini/voronoidiagram/UniformGrid$PointIterator.class
new file mode 100644
index 0000000000000000000000000000000000000000..62dcac846177a2f22b9cd5822f6d8d12fbad0981
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/UniformGrid$PointIterator.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/UniformGrid.class b/bin/plugins/ragini/voronoidiagram/UniformGrid.class
new file mode 100644
index 0000000000000000000000000000000000000000..7788a035447a78a7f92a2b2e9cf8c85556fe553f
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/UniformGrid.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/VRegion$scomp.class b/bin/plugins/ragini/voronoidiagram/VRegion$scomp.class
new file mode 100644
index 0000000000000000000000000000000000000000..f0e5bc2a1384f253913fb7a4aec58e6146dbc265
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/VRegion$scomp.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/VRegion$vtcomp.class b/bin/plugins/ragini/voronoidiagram/VRegion$vtcomp.class
new file mode 100644
index 0000000000000000000000000000000000000000..91bc2139580a584275f9ab14946ebb1541a5dae9
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/VRegion$vtcomp.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/VRegion.class b/bin/plugins/ragini/voronoidiagram/VRegion.class
new file mode 100644
index 0000000000000000000000000000000000000000..1471d6510037b85c21b50270484a41e4fc600eae
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/VRegion.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Vert.class b/bin/plugins/ragini/voronoidiagram/Vert.class
new file mode 100644
index 0000000000000000000000000000000000000000..a7f2842be723e3e3eab46053af7e9d87e0479fe0
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Vert.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/VertTheta.class b/bin/plugins/ragini/voronoidiagram/VertTheta.class
new file mode 100644
index 0000000000000000000000000000000000000000..8c6215f50d340169bcd5217814409fafe38380f1
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/VertTheta.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Vertex.class b/bin/plugins/ragini/voronoidiagram/Vertex.class
new file mode 100644
index 0000000000000000000000000000000000000000..83c1f0f44486d7afe0fa146caaa2a756c864e498
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Vertex.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Vonoroi$GLscomp.class b/bin/plugins/ragini/voronoidiagram/Vonoroi$GLscomp.class
new file mode 100644
index 0000000000000000000000000000000000000000..2fc052d62cc3754d5bd33591508bd6009e2c3fd5
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Vonoroi$GLscomp.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/Vonoroi.class b/bin/plugins/ragini/voronoidiagram/Vonoroi.class
new file mode 100644
index 0000000000000000000000000000000000000000..f73fed301a91ddbc16667025e9c358180f22dcbe
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/Vonoroi.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$1.class b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..7d58e8aae4c5ca48f2bbef413d11c35e1bc5c0af
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$1.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$2.class b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$2.class
new file mode 100644
index 0000000000000000000000000000000000000000..7ee89814ccb6cf9482a2ab2d5ae2481605467144
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$2.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$MethodType.class b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$MethodType.class
new file mode 100644
index 0000000000000000000000000000000000000000..2776a301b394ef1ff036df6a52a1d45750a99215
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$MethodType.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$buttonlist.class b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$buttonlist.class
new file mode 100644
index 0000000000000000000000000000000000000000..ba7298c4d3b57d600e3f139943774c09590f65d6
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram$buttonlist.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/VoronoiDiagram.class b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram.class
new file mode 100644
index 0000000000000000000000000000000000000000..32ea41cc352f2d4d6fddbfcbfb188c9348566b99
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/VoronoiDiagram.class differ
diff --git a/bin/plugins/ragini/voronoidiagram/dkmax.class b/bin/plugins/ragini/voronoidiagram/dkmax.class
new file mode 100644
index 0000000000000000000000000000000000000000..837754a7213db5c06f2aa413d6d777525679c0e7
Binary files /dev/null and b/bin/plugins/ragini/voronoidiagram/dkmax.class differ
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..16157b01b43f90fcdacdca1e65d31a01f5f1f0d3
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <!-- Inherited Icy Parent POM -->
+ <parent>
+ <groupId>org.bioimageanalysis.icy</groupId>
+ <artifactId>parent-pom-plugin</artifactId>
+ <version>1.0.3</version>
+ </parent>
+
+ <!-- Project Information -->
+ <artifactId>voronoi</artifactId>
+ <version>1.0.0</version>
+
+ <packaging>jar</packaging>
+
+ <name>Voronoi</name>
+ <description></description>
+ <url></url>
+ <inceptionYear>2020</inceptionYear>
+
+ <organization>
+ <name>Institut Pasteur</name>
+ <url>https://pasteur.fr</url>
+ </organization>
+
+ <licenses>
+ <license>
+ <name>GNU GPLv3</name>
+ <url>https://www.gnu.org/licenses/gpl-3.0.en.html</url>
+ <distribution>repo</distribution>
+ </license>
+ </licenses>
+
+ <developers>
+ <developer>
+ <id>sdallongeville</id>
+ <name>Stéphane Dallongeville</name>
+ <url>https://research.pasteur.fr/fr/member/stephane-dallongeville/</url>
+ <roles>
+ <role>founder</role>
+ <role>lead</role>
+ <role>architect</role>
+ <role>developer</role>
+ <role>debugger</role>
+ <role>tester</role>
+ <role>maintainer</role>
+ <role>support</role>
+ </roles>
+ </developer>
+ </developers>
+
+ <!-- Project properties -->
+ <properties>
+
+ </properties>
+
+ <!-- Project build configuration -->
+ <build>
+
+ </build>
+
+ <!-- List of project's dependencies -->
+ <dependencies>
+ <!-- The core of Icy -->
+ <dependency>
+ <groupId>org.bioimageanalysis.icy</groupId>
+ <artifactId>icy-kernel</artifactId>
+ </dependency>
+
+ </dependencies>
+
+ <!-- Icy Maven repository (to find parent POM) -->
+ <repositories>
+ <repository>
+ <id>icy</id>
+ <name>Icy's Nexus</name>
+ <url>https://icy-nexus.pasteur.fr/repository/Icy/</url>
+ </repository>
+ </repositories>
+</project>
\ No newline at end of file
diff --git a/src/main/java/plugins/ragini/voronoidiagram/AFL.java b/src/main/java/plugins/ragini/voronoidiagram/AFL.java
new file mode 100644
index 0000000000000000000000000000000000000000..454d347292b415c517645c995bc82727388b461f
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/AFL.java
@@ -0,0 +1,89 @@
+package plugins.ragini.voronoidiagram;
+
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: AFL.java
+
+import java.io.PrintStream;
+import java.util.Vector;
+
+//Referenced classes of package delaunay:
+// QuadEdge
+
+public class AFL
+{
+
+ public AFL()
+ {
+ list = new Vector();
+ }
+
+ public QuadEdge putTest(QuadEdge e)
+ {
+ int index = contains(e);
+ if(index >= 0)
+ {
+ return (QuadEdge)list.remove(index);
+ } else
+ {
+ list.add(e);
+ return null;
+ }
+ }
+
+ public void put(QuadEdge e)
+ {
+ list.add(e);
+ }
+
+ public void remove(QuadEdge e)
+ {
+ list.remove(e);
+ }
+
+ public int contains(QuadEdge e1)
+ {
+ int index;
+ for(index = 0; index < list.size(); index++)
+ {
+ QuadEdge e2 = get(index);
+ if(e1.equals(e2) || e1.equals(e2.sym()))
+ break;
+ }
+
+ if(index < list.size())
+ return index;
+ else
+ return -1;
+ }
+
+ public boolean isEmpty()
+ {
+ return list.isEmpty();
+ }
+
+ public QuadEdge extract()
+ {
+ return (QuadEdge)list.remove(0);
+ }
+
+ public int size()
+ {
+ return list.size();
+ }
+
+ QuadEdge get(int index)
+ {
+ return (QuadEdge)list.elementAt(index);
+ }
+
+ public void print()
+ {
+ for(int i = 0; i < list.size(); i++)
+ System.out.println((new StringBuilder("[")).append(get(i).orig()).append(",").append(get(i).dest()).append("]").toString());
+
+ }
+
+ private Vector list;
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Alpha_Morph.java b/src/main/java/plugins/ragini/voronoidiagram/Alpha_Morph.java
new file mode 100644
index 0000000000000000000000000000000000000000..4ecf47b6dd96db0f4c81789e6bdbf7f434b7cd63
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Alpha_Morph.java
@@ -0,0 +1,1327 @@
+package plugins.ragini.voronoidiagram;
+
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: Alpha_Morph.java
+
+
+import ij.ImagePlus;
+import ij.WindowManager;
+import ij.gui.GUI;
+import ij.plugin.frame.PlugInFrame;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.File;
+import java.io.PrintStream;
+import java.util.Vector;
+import javax.swing.*;
+
+//Referenced classes of package delaunay:
+// DelaunayTriangulator, Display, DT, Vertex
+
+public class Alpha_Morph extends PlugInFrame
+ implements Runnable
+{
+
+ public Alpha_Morph(Neighbor[] data, double _minx, double _miny, double _maxx, double _maxy)
+ {
+ super("Alpha_Morph");
+ minx = _minx;
+ miny = _miny;
+ maxx = _maxx;
+ maxy = _maxy;
+ load = data;
+ running = false;
+ waiting = true;
+ counter = 0;
+ canAddPoints = true;
+ fileImage = null;
+ rnd = 30;
+ rank = 0;
+ rank2 = 0;
+ toggle = 0;
+ toggle1 = 1;
+ toggle2 = 2;
+ toggle3 = 3;
+ toggleBin = 0;
+ angle = -1D;
+ epsilon = 0.39269908169872414D;
+ myThread = null;
+ sites = null;
+ sitesBin = null;
+ dt = new DelaunayTriangulator[4];
+ disp = new Display[4];
+ for(int i = 0; i < 4; i++)
+ {
+ dt[i] = new DelaunayTriangulator();
+ disp[i] = new Display(dt[i]);
+ }
+
+ slider = new JSlider(0, 360, 0);
+ slider_opacity = new JSlider(0, 100, 100);
+ b1 = new Button(" Process All ");
+ b2 = new Button(" Seeds ");
+ b3 = new Button(" Dual ");
+ bComp = new Button(" Comp ");
+ b6 = new Button(" Binarize ");
+ bE = new Button(" Erode ");
+ tOrdre = new TextField((new StringBuilder(String.valueOf(rank))).toString(), 2);
+ tOrdre2 = new TextField((new StringBuilder(String.valueOf(rank2))).toString(), 2);
+ bD = new Button(" Dilation ");
+ bDFuzzy = new Button(" Fuzzy Dilation ");
+ b4 = new Button(" Clear ");
+ // b5 = new Button(" Generate ");
+ b7 = new Button(" Load Point Set ");
+ // b8 = new Button(" Save Point Set ");
+ //i7 = new Button(" Load Image ");
+ i8 = new Button(" Save Image ");
+ bC = new Button("Edges/Faces");
+ // bConv = new Button("Convert");
+ bInter = new Button(" Binary Op.");
+ t0 = new TextField("1", 2);
+ t1 = new TextField((new StringBuilder(String.valueOf(rnd))).toString(), 2);
+ t2 = new TextField((new StringBuilder(String.valueOf(DT.densityParameter))).toString(), 2);
+ t3 = new TextField((new StringBuilder(String.valueOf(DT.vertexAngle.x))).toString(), 2);
+ t4 = new TextField((new StringBuilder(String.valueOf(DT.jitter))).toString(), 2);
+ t8 = new TextField("22.5", 2);
+ tvoid = new TextField("", 2);
+ log = new TextArea(10, 20);
+ p1 = new Panel();
+ p2 = new Panel();
+ p3 = new Panel();
+ p4 = new Panel();
+ init();
+ }
+
+ public void init()
+ {
+ p1.setLayout(new FlowLayout());
+ p1.add(b1);
+ p1.add(b2);
+ p1.add(b4);
+ //p1.add(b5);
+ p1.add(b3);
+ p1.add(bComp);
+ p1.add(b6);
+ p1.add(bE);
+ p1.add(tOrdre);
+ p1.add(bD);
+ p1.add(bDFuzzy);
+ p1.add(tOrdre2);
+ p2.setLayout(new GridLayout(16, 2));
+ p2.add(b7);
+ // p2.add(b8);
+ //p2.add(i7);
+ p2.add(i8);
+ p2.add(new Label("Scale Factor "));
+ p2.add(t0);
+ p2.add(new Label("Random points "));
+ p2.add(t1);
+ p2.add(new Label("Density parameter "));
+ p2.add(t2);
+ p2.add(new Label("Jitter "));
+ p2.add(t4);
+ JRadioButton type1 = new JRadioButton("Size");
+ JRadioButton type2 = new JRadioButton("Radius", true);
+ ButtonGroup tbb = new ButtonGroup();
+ tbb.add(type1);
+ tbb.add(type2);
+ class _cls1SelectItemListenerTb
+ implements ItemListener
+ {
+
+ public void itemStateChanged(ItemEvent e)
+ {
+ AbstractButton sel = (AbstractButton)e.getItemSelectable();
+ if(e.getStateChange() == 1)
+ if(sel.getText().equals("Radius"))
+ DT.type = 1;
+ else
+ if(sel.getText().equals("Size"))
+ DT.type = 0;
+ }
+
+ final Alpha_Morph this$0;
+
+ _cls1SelectItemListenerTb()
+ {
+ super();
+ this$0 = Alpha_Morph.this;
+ }
+ }
+
+ type1.addItemListener(new _cls1SelectItemListenerTb());
+ type2.addItemListener(new _cls1SelectItemListenerTb());
+ JPanel pTb = new JPanel();
+ pTb.add(type1);
+ pTb.add(type2);
+ p2.add(new Label("Criterium: "));
+ p2.add(pTb);
+ p2.add(bC);
+ // p2.add(bConv);
+ p2.add(new Label("Opacity "));
+ p2.add(slider_opacity);
+ p2.add(new Label("Angle morpho "));
+ p2.add(slider);
+ p2.add(new Label("Angle"));
+ p2.add(new Label("Epsilon"));
+ p2.add(t3);
+ p2.add(t8);
+ p2.add(new Label("Binary Operators ..."));
+ p2.add(tvoid);
+ JRadioButton rbb1 = new JRadioButton("1");
+ JRadioButton rbb2 = new JRadioButton("2", true);
+ JRadioButton rbb3 = new JRadioButton("3");
+ JRadioButton rbb4 = new JRadioButton("4");
+ ButtonGroup bgg = new ButtonGroup();
+ bgg.add(rbb1);
+ bgg.add(rbb2);
+ bgg.add(rbb3);
+ bgg.add(rbb4);
+ class _cls1SelectItemListener1
+ implements ItemListener
+ {
+
+ public void itemStateChanged(ItemEvent e)
+ {
+ AbstractButton sel = (AbstractButton)e.getItemSelectable();
+ if(e.getStateChange() == 1)
+ if(sel.getText().equals("1"))
+ toggle1 = 0;
+ else
+ if(sel.getText().equals("2"))
+ toggle1 = 1;
+ else
+ if(sel.getText().equals("3"))
+ toggle1 = 2;
+ else
+ if(sel.getText().equals("4"))
+ toggle1 = 3;
+ }
+
+ final Alpha_Morph this$0;
+
+ _cls1SelectItemListener1()
+ {
+ super();
+ this$0 = Alpha_Morph.this;
+ }
+ }
+
+ rbb1.addItemListener(new _cls1SelectItemListener1());
+ rbb2.addItemListener(new _cls1SelectItemListener1());
+ rbb3.addItemListener(new _cls1SelectItemListener1());
+ rbb4.addItemListener(new _cls1SelectItemListener1());
+ JPanel p6 = new JPanel();
+ p6.add(rbb1);
+ p6.add(rbb2);
+ p6.add(rbb3);
+ p6.add(rbb4);
+ p2.add(new Label("Operand 1"));
+ p2.add(p6);
+ JRadioButton rbbb1 = new JRadioButton("1");
+ JRadioButton rbbb2 = new JRadioButton("2");
+ JRadioButton rbbb3 = new JRadioButton("3", true);
+ JRadioButton rbbb4 = new JRadioButton("4");
+ ButtonGroup bggg = new ButtonGroup();
+ bggg.add(rbbb1);
+ bggg.add(rbbb2);
+ bggg.add(rbbb3);
+ bggg.add(rbbb4);
+ class _cls1SelectItemListener2
+ implements ItemListener
+ {
+
+ public void itemStateChanged(ItemEvent e)
+ {
+ AbstractButton sel = (AbstractButton)e.getItemSelectable();
+ if(e.getStateChange() == 1)
+ if(sel.getText().equals("1"))
+ toggle2 = 0;
+ else
+ if(sel.getText().equals("2"))
+ toggle2 = 1;
+ else
+ if(sel.getText().equals("3"))
+ toggle2 = 2;
+ else
+ if(sel.getText().equals("4"))
+ toggle2 = 3;
+ }
+
+ final Alpha_Morph this$0;
+
+ _cls1SelectItemListener2()
+ {
+ super();
+ this$0 = Alpha_Morph.this;
+ }
+ }
+
+ rbbb1.addItemListener(new _cls1SelectItemListener2());
+ rbbb2.addItemListener(new _cls1SelectItemListener2());
+ rbbb3.addItemListener(new _cls1SelectItemListener2());
+ rbbb4.addItemListener(new _cls1SelectItemListener2());
+ JPanel p7 = new JPanel();
+ p7.add(rbbb1);
+ p7.add(rbbb2);
+ p7.add(rbbb3);
+ p7.add(rbbb4);
+ p2.add(new Label("Operand 2"));
+ p2.add(p7);
+ JRadioButton rbbbb1 = new JRadioButton("1");
+ JRadioButton rbbbb2 = new JRadioButton("2");
+ JRadioButton rbbbb3 = new JRadioButton("3");
+ JRadioButton rbbbb4 = new JRadioButton("4", true);
+ ButtonGroup bgggg = new ButtonGroup();
+ bgggg.add(rbbbb1);
+ bgggg.add(rbbbb2);
+ bgggg.add(rbbbb3);
+ bgggg.add(rbbbb4);
+ class _cls1SelectItemListener3
+ implements ItemListener
+ {
+
+ public void itemStateChanged(ItemEvent e)
+ {
+ AbstractButton sel = (AbstractButton)e.getItemSelectable();
+ if(e.getStateChange() == 1)
+ if(sel.getText().equals("1"))
+ toggle3 = 0;
+ else
+ if(sel.getText().equals("2"))
+ toggle3 = 1;
+ else
+ if(sel.getText().equals("3"))
+ toggle3 = 2;
+ else
+ if(sel.getText().equals("4"))
+ toggle3 = 3;
+ }
+
+ final Alpha_Morph this$0;
+
+ _cls1SelectItemListener3()
+ {
+ super();
+ this$0 = Alpha_Morph.this;
+ }
+ }
+
+ rbbbb1.addItemListener(new _cls1SelectItemListener3());
+ rbbbb2.addItemListener(new _cls1SelectItemListener3());
+ rbbbb3.addItemListener(new _cls1SelectItemListener3());
+ rbbbb4.addItemListener(new _cls1SelectItemListener3());
+ JPanel p8 = new JPanel();
+ p8.add(rbbbb1);
+ p8.add(rbbbb2);
+ p8.add(rbbbb3);
+ p8.add(rbbbb4);
+ p2.add(new Label("Result"));
+ p2.add(p8);
+ JRadioButton rb1 = new JRadioButton("1", true);
+ JRadioButton rb2 = new JRadioButton("2");
+ JRadioButton rb3 = new JRadioButton("3");
+ JRadioButton rb4 = new JRadioButton("4");
+ ButtonGroup bg = new ButtonGroup();
+ bg.add(rb1);
+ bg.add(rb2);
+ bg.add(rb3);
+ bg.add(rb4);
+ class _cls1SelectItemListener
+ implements ItemListener
+ {
+
+ public void itemStateChanged(ItemEvent e)
+ {
+ AbstractButton sel = (AbstractButton)e.getItemSelectable();
+ if(e.getStateChange() == 1)
+ if(sel.getText().equals("1"))
+ toggle = 0;
+ else
+ if(sel.getText().equals("2"))
+ toggle = 1;
+ else
+ if(sel.getText().equals("3"))
+ toggle = 2;
+ else
+ if(sel.getText().equals("4"))
+ toggle = 3;
+ }
+
+ final Alpha_Morph this$0;
+
+ _cls1SelectItemListener()
+ {
+ super();
+ this$0 = Alpha_Morph.this;
+ }
+ }
+
+ rb1.addItemListener(new _cls1SelectItemListener());
+ rb2.addItemListener(new _cls1SelectItemListener());
+ rb3.addItemListener(new _cls1SelectItemListener());
+ rb4.addItemListener(new _cls1SelectItemListener());
+ JPanel p5 = new JPanel();
+ p5.add(rb1);
+ p5.add(rb2);
+ p5.add(rb3);
+ p5.add(rb4);
+ p1.add(p5);
+ p1.add(bInter);
+ JRadioButton rbbin1 = new JRadioButton("Inter", true);
+ JRadioButton rbbin2 = new JRadioButton("Union");
+ ButtonGroup bgbin = new ButtonGroup();
+ bgbin.add(rbbin1);
+ bgbin.add(rbbin2);
+ class _cls1SelectItemListenerBin
+ implements ItemListener
+ {
+
+ public void itemStateChanged(ItemEvent e)
+ {
+ AbstractButton sel = (AbstractButton)e.getItemSelectable();
+ if(e.getStateChange() == 1)
+ if(sel.getText().equals("Inter"))
+ toggleBin = 0;
+ else
+ if(sel.getText().equals("Union"))
+ toggleBin = 1;
+ }
+
+ final Alpha_Morph this$0;
+
+ _cls1SelectItemListenerBin()
+ {
+ super();
+ this$0 = Alpha_Morph.this;
+ }
+ }
+
+ rbbin1.addItemListener(new _cls1SelectItemListenerBin());
+ rbbin2.addItemListener(new _cls1SelectItemListenerBin());
+ JPanel p9 = new JPanel();
+ p9.add(rbbin1);
+ p9.add(rbbin2);
+ p1.add(p9);
+ p3.setLayout(new BorderLayout());
+ p3.add("Center", log);
+ p3.add("North", p2);
+ reset();
+ p4.setLayout(new GridLayout(2, 2));
+ for(int i = 0; i < 4; i++)
+ p4.add(disp[i]);
+
+ add("Center", p4);
+ add("East", p3);
+ add("South", p1);
+ pack();
+ GUI.center(this);
+ setVisible(true);
+ slider.setMajorTickSpacing(20);
+ slider.setMinorTickSpacing(10);
+ slider.setPaintTicks(false);
+ slider.setPaintLabels(false);
+ slider_opacity.setMajorTickSpacing(10);
+ slider_opacity.setMinorTickSpacing(5);
+ slider_opacity.setPaintTicks(false);
+ slider_opacity.setPaintLabels(false);
+ slider.addMouseListener(new MouseListener() {
+ {
+ //super();
+ this$0 = Alpha_Morph.this;
+ }
+
+ public void mousePressed(MouseEvent mouseevent)
+ {
+ }
+
+ public void mouseClicked(MouseEvent mouseevent)
+ {
+ }
+
+ public void mouseReleased(MouseEvent me)
+ {
+ angle = (360 * me.getX()) / slider.getWidth();
+ if(angle > 360D)
+ angle = 360D;
+ if(angle < 0.0D)
+ angle = 0.0D;
+ String angleS = (new StringBuilder()).append(angle).toString();
+ slider.setValue((int)angle / 1);
+ t3.setText(angleS);
+ try
+ {
+ double angleRadian = ((360D - angle) * 3.1415926535897931D * 2D) / 360D;
+ DT.vertexAngle.x = Math.cos(angleRadian);
+ DT.vertexAngle.y = Math.sin(angleRadian);
+ }
+ catch(NumberFormatException nfe)
+ {
+ DT.vertexAngle.x = -1D;
+ DT.vertexAngle.y = -1D;
+ }
+ }
+
+ public void mouseEntered(MouseEvent mouseevent)
+ {
+ }
+
+ public void mouseExited(MouseEvent mouseevent)
+ {
+ }
+
+ final Alpha_Morph this$0;
+
+
+ }
+);
+ slider_opacity.addMouseListener(new MouseListener() {
+
+ public void mousePressed(MouseEvent mouseevent)
+ {
+ }
+
+ public void mouseClicked(MouseEvent mouseevent)
+ {
+ }
+
+ public void mouseReleased(MouseEvent me)
+ {
+ DT.opacity = (float)me.getX() / (float)slider.getWidth();
+ disp[toggle].repaint();
+ }
+
+ public void mouseEntered(MouseEvent mouseevent)
+ {
+ }
+
+ public void mouseExited(MouseEvent mouseevent)
+ {
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ t0.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ String s = e.getActionCommand();
+ try
+ {
+ DT.res = Float.valueOf(s).intValue();
+ }
+ catch(NumberFormatException nfe)
+ {
+ DT.res = 1.0D;
+ }
+ if(DT.res < 1.0D)
+ DT.res = 1.0D;
+ t0.setText((new StringBuilder(String.valueOf(DT.res))).toString());
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ t1.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ String s = e.getActionCommand();
+ try
+ {
+ rnd = Integer.valueOf(s).intValue();
+ }
+ catch(NumberFormatException nfe)
+ {
+ rnd = 30;
+ }
+ if(rnd < 3)
+ rnd = 3;
+ t1.setText((new StringBuilder(String.valueOf(rnd))).toString());
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ t2.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ String s = e.getActionCommand();
+ try
+ {
+ DT.densityParameter = Double.valueOf(s).doubleValue();
+ }
+ catch(NumberFormatException nfe)
+ {
+ DT.densityParameter = 1.5D;
+ }
+ if(DT.densityParameter < 0.0D)
+ DT.densityParameter = 1.0D;
+ t2.setText((new StringBuilder(String.valueOf(DT.densityParameter))).toString());
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ /// super();
+ }
+ }
+);
+ t3.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ String s = e.getActionCommand();
+ angle = -1D;
+ try
+ {
+ angle = Double.valueOf(s).doubleValue();
+ if(angle < 0.0D)
+ {
+ DT.vertexAngle.x = -1D;
+ DT.vertexAngle.y = -1D;
+ } else
+ {
+ double angleRadian = ((360D - angle) * 3.1415926535897931D * 2D) / 360D;
+ DT.vertexAngle.x = Math.cos(angleRadian);
+ DT.vertexAngle.y = Math.sin(angleRadian);
+ }
+ }
+ catch(NumberFormatException nfe)
+ {
+ DT.vertexAngle.x = -1D;
+ DT.vertexAngle.y = -1D;
+ }
+ t3.setText((new StringBuilder(String.valueOf(angle))).toString());
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);
+ t4.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ String s = e.getActionCommand();
+ try
+ {
+ DT.jitter = Double.valueOf(s).doubleValue();
+ }
+ catch(NumberFormatException nfe)
+ {
+ DT.jitter = 0.0D;
+ }
+ if(DT.jitter > 0.10000000000000001D)
+ DT.jitter = 0.0D;
+ if(DT.jitter < -0.10000000000000001D)
+ DT.jitter = 0.0D;
+ t4.setText((new StringBuilder(String.valueOf(DT.jitter))).toString());
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ t8.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ String s = e.getActionCommand();
+ epsilon = 0.39269908169872414D;
+ try
+ {
+ epsilon = Double.valueOf(s).doubleValue();
+ if(epsilon < 0.0D)
+ epsilon = 0.0D;
+ else
+ epsilon = (epsilon * 3.1415926535897931D) / 180D;
+ }
+ catch(NumberFormatException nfe)
+ {
+ epsilon = 0.39269908169872414D;
+ }
+ t8.setText((new StringBuilder(String.valueOf((epsilon * 180D) / 3.1415926535897931D))).toString());
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ tOrdre.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ String s = e.getActionCommand();
+ try
+ {
+ rank = Integer.valueOf(s).intValue();
+ }
+ catch(NumberFormatException nfe)
+ {
+ rank = 0;
+ }
+ if(rank < 0)
+ rank = 0;
+ tOrdre.setText((new StringBuilder(String.valueOf(rank))).toString());
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);
+ tOrdre2.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ String s = e.getActionCommand();
+ try
+ {
+ rank2 = Integer.valueOf(s).intValue();
+ }
+ catch(NumberFormatException nfe)
+ {
+ rank2 = 0;
+ }
+ if(rank2 < 0)
+ rank2 = 0;
+ tOrdre.setText((new StringBuilder(String.valueOf(rank2))).toString());
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ b1.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ if(waiting)
+ waiting = false;
+ for(int i = 0; i < 4; i++)
+ disp[i].run(0);
+
+ b6.setEnabled(true);
+ b3.setEnabled(true);
+ bE.setEnabled(true);
+ bD.setEnabled(true);
+ tOrdre.setEnabled(true);
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);
+ b2.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ disp[toggle].swap(18);
+ if(b2.getBackground() == Color.RED)
+ b2.setBackground(Color.LIGHT_GRAY);
+ else
+ b2.setBackground(Color.RED);
+ if(b6.isEnabled())
+ b6.setEnabled(false);
+ else
+ b6.setEnabled(true);
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ b3.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ disp[toggle].swap(13);
+ disp[toggle].repaint();
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ bComp.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ dt[toggle].constructComp();
+ disp[toggle].repaint();
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ b4.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ reset();
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ /* b5.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ reset();
+ disp[toggle].resetAll(true);
+ disp[toggle].clearPoints();
+ disp[toggle].enableAdding(true);
+ disp[toggle].loadPoints(rnd, minx, miny, maxx, maxy, load);
+ disp[toggle].show(10);
+ disp[toggle].repaint();
+ b1.setEnabled(true);
+ b3.setEnabled(false);
+ b6.setEnabled(false);
+ bE.setEnabled(false);
+ bD.setEnabled(false);
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);*/
+ b6.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ rank = 0;
+ disp[toggle].setRank(rank);
+ rank2 = 0;
+ disp[toggle].setRank2(rank2);
+ tOrdre.setText((new Integer(rank)).toString());
+ tOrdre2.setText((new Integer(rank2)).toString());
+ dt[toggle].constructBin(sitesBin);
+ disp[toggle].hide(11);
+ disp[toggle].repaint();
+ b6.setEnabled(false);
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);
+ bE.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ rank++;
+ disp[toggle].setRank(rank);
+ tOrdre.setText((new Integer(rank)).toString());
+ dt[toggle].constructErode();
+ disp[toggle].repaint();
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);
+ bD.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ rank2++;
+ disp[toggle].setRank2(rank2);
+ tOrdre2.setText((new Integer(rank2)).toString());
+ dt[toggle].constructDilate(angle, epsilon);
+ disp[toggle].repaint();
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ bDFuzzy.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ dt[toggle].constructFuzzyDilate(angle, epsilon);
+ disp[toggle].repaint();
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ bInter.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ disp[toggle].run(0);
+ disp[toggle3].hide(11);
+ if(toggleBin == 0)
+ dt[toggle3].constructInter(dt[toggle1], dt[toggle2]);
+ else
+ dt[toggle3].constructUnion(dt[toggle1], dt[toggle2]);
+ disp[toggle3].repaint();
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ bC.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ disp[toggle].swap(17);
+ disp[toggle].repaint();
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ /* bConv.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ final JFrame frame = new JFrame();
+ frame.setLocationRelativeTo(null);
+ frame.setVisible(true);
+ final Dialog d = new Dialog(frame, (new StringBuilder("The jitter parameter will be set to ")).append(DT.jitter).toString());
+ d.setVisible(true);
+ d.setSize(400, 100);
+ d.setLocationRelativeTo(frame);
+ Button dbtn;
+ d.add(dbtn = new Button("OK"), "South");
+ dbtn.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ d.dispose();
+ frame.dispose();
+ disp[toggle].convertImage();
+ }
+
+ final _cls23 this$1;
+ private final Dialog val$d;
+ private final JFrame val$frame;
+
+
+ {
+ this$1 = _cls23.this;
+ d = dialog;
+ frame = jframe;
+ super();
+ }
+ }
+);
+ }
+
+ final Alpha_Morph this$0;
+
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);*/
+ b7.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ reset();
+ disp[toggle].resetAll(true);
+ disp[toggle].clearPoints();
+ disp[toggle].enableAdding(true);
+ disp[toggle].loadPoints(rnd, minx, miny, maxx, maxy, load);
+ disp[toggle].show(10);
+ disp[toggle].repaint();
+ b1.setEnabled(true);
+ b3.setEnabled(false);
+ b6.setEnabled(false);
+ bE.setEnabled(false);
+ bD.setEnabled(false);
+
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);
+ /* b8.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ JFrame frame = new JFrame("File");
+ FileDialog fd = new FileDialog(frame, "Quel fichier ?", 1);
+ fd.setVisible(true);
+ String selectedItem = fd.getFile();
+ if(selectedItem != null)
+ {
+ File file = new File((new StringBuilder(String.valueOf(fd.getDirectory()))).append(File.separator).append(fd.getFile()).toString());
+ System.out.println((new StringBuilder("saving file ")).append(fd.getDirectory()).append(File.separator).append(fd.getFile()).toString());
+ disp[toggle].writePoints(file);
+ }
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);*/
+ /* i7.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ ImagePlus imp = WindowManager.getCurrentImage();
+ if(imp == null)
+ {
+ JFrame frame = new JFrame();
+ FileDialog fd = new FileDialog(frame, "Quel fichier ?", 0);
+ fd.setVisible(true);
+ String selectedItem = fd.getFile();
+ if(selectedItem != null)
+ {
+ File file = new File((new StringBuilder(String.valueOf(fd.getDirectory()))).append(File.separator).append(fd.getFile()).toString());
+ System.out.println((new StringBuilder("loading file ")).append(fd.getDirectory()).append(File.separator).append(fd.getFile()).toString());
+ fileImage = file;
+ disp[toggle].loadImage(file);
+ }
+ return;
+ } else
+ {
+ java.awt.Image image = imp.getImage();
+ disp[toggle].loadImage(image);
+ return;
+ }
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ //super();
+ }
+ }
+);*/
+ i8.addActionListener(new ActionListener() {
+
+ public void actionPerformed(ActionEvent e)
+ {
+ JFrame frame = new JFrame("File");
+ FileDialog fd = new FileDialog(frame, "Quel fichier ?", 1);
+ fd.setVisible(true);
+ String selectedItem = fd.getFile();
+ if(selectedItem != null)
+ {
+ File file = new File((new StringBuilder(String.valueOf(fd.getDirectory()))).append(File.separator).append(fd.getFile()).toString());
+ System.out.println((new StringBuilder("saving file ")).append(fd.getDirectory()).append(File.separator).append(fd.getFile()).toString());
+ disp[toggle].writeImage(file);
+ }
+ }
+
+ final Alpha_Morph this$0;
+
+
+ {
+ this$0 = Alpha_Morph.this;
+ // super();
+ }
+ }
+);
+ myThread = new Thread(this);
+ myThread.start();
+ }
+
+ public void reset()
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ disp[i].resetAll(true);
+ disp[i].clearPoints();
+ disp[i].enableAdding(true);
+ disp[i].show(10);
+ disp[i].hide(17);
+ disp[i].hide(11);
+ disp[i].hide(18);
+ disp[i].repaint();
+ dt[i].resetAll();
+ }
+
+ running = false;
+ sites = null;
+ sitesBin = null;
+ counter = 0;
+ b1.setEnabled(false);
+ b2.setEnabled(false);
+ b3.setEnabled(false);
+ b4.setEnabled(true);
+ //b5.setEnabled(true);
+ b6.setEnabled(false);
+ bE.setEnabled(false);
+ bD.setEnabled(false);
+ bC.setEnabled(true);
+ b2.setBackground(Color.LIGHT_GRAY);
+ }
+
+ public void run()
+ {
+ do
+ {
+ b4.setEnabled(true);
+ //b5.setEnabled(true);
+ while(waiting)
+ if(disp[toggle].numPoints() > 2)
+ {
+ b1.setEnabled(true);
+ b2.setEnabled(true);
+ }
+ b4.setEnabled(false);
+ // b5.setEnabled(false);
+ for(int i = 0; i < 4; i++)
+ {
+ disp[toggle].resetAll(false);
+ dt[toggle].resetAll();
+ }
+
+ b2.setBackground(Color.LIGHT_GRAY);
+ disp[toggle].enableAdding(true);
+ running = true;
+ sites = disp[toggle].getPoints();
+ disp[toggle].setSites(sites);
+ disp[toggle].show(8);
+ for(int i = 0; i < 4; i++)
+ if(i != toggle)
+ {
+ disp[i].setPoints(sites);
+ disp[i].setSites(sites);
+ disp[i].show(8);
+ disp[i].repaint();
+ }
+
+ sitesBin = disp[toggle].getPointsBin();
+ disp[toggle].show(11);
+ disp[toggle].show(5);
+ disp[toggle].show(6);
+ disp[toggle].show(1);
+ startTime = System.currentTimeMillis();
+ if(counter == 0)
+ {
+ for(int i = 0; i < 4; i++)
+ {
+ dt[i].inCoDeTotal(disp[i], sites, sitesBin);
+ dt[i].setMeasure();
+ }
+
+ } else
+ {
+ dt[toggle].inCoDeTotal(disp[toggle], sites, sitesBin);
+ dt[toggle].setMeasure();
+ }
+ counter++;
+ endTime = System.currentTimeMillis();
+ time = endTime - startTime;
+ time /= 4D;
+ log.append("Algorithm: Incremental construction\n");
+ log.append((new StringBuilder("Total vertices: ")).append(disp[toggle].numPoints()).append("\n").toString());
+ log.append((new StringBuilder("Total edges: ")).append(dt[toggle].getEdges().size()).append("\n").toString());
+ log.append((new StringBuilder("Total faces: ")).append(dt[toggle].getFaces().size()).append("\n").toString());
+ int eulerNumber = (dt[toggle].getFaces().size() - dt[toggle].getEdges().size()) + disp[toggle].numPoints();
+ log.append((new StringBuilder("Euler number: ")).append(eulerNumber).append("\n").toString());
+ log.append((new StringBuilder("No. of Delaunay tests: ")).append(DT.counter2).append("\n").toString());
+ log.append((new StringBuilder("Mesure Mean: ")).append(dt[toggle].getMeasureMean()).append(" \n").toString());
+ log.append((new StringBuilder("Mesure Median: ")).append(dt[toggle].getMeasureMedian()).append(" \n").toString());
+ log.append("\n");
+ log.append((new StringBuilder("Elapsed time: ")).append(time).append(" msec\n").toString());
+ log.append("\n");
+ for(int i = 0; i < 4; i++)
+ disp[i].enableAdding(true);
+
+ disp[toggle].repaint();
+ running = false;
+ waiting = true;
+ } while(true);
+ }
+
+ boolean running;
+ boolean waiting;
+ int counter;
+ boolean canAddPoints;
+ File fileImage;
+ int rnd;
+ int rank;
+ int rank2;
+ int toggle;
+ int toggle1;
+ int toggle2;
+ int toggle3;
+ int toggleBin;
+ long startTime;
+ long endTime;
+ long time;
+ double angle;
+ double epsilon;
+ private Thread myThread;
+ Neighbor[] load;
+ Vertex sites[];
+ Vertex sitesBin[];
+ DelaunayTriangulator dt[];
+ Display disp[];
+ JSlider slider;
+ JSlider slider_opacity;
+ Button b1;
+ Button b2;
+ Button b3;
+ Button bComp;
+ Button b6;
+ Button bE;
+ TextField tOrdre;
+ TextField tOrdre2;
+ Button bD;
+ Button bDFuzzy;
+ Button b4;
+// Button b5;
+ Button b7;
+ //Button b8;
+ //Button i7;
+ Button i8;
+ Button bC;
+// Button bConv;
+ Button bInter;
+ TextField t0;
+ TextField t1;
+ TextField t2;
+ TextField t3;
+ TextField t4;
+ TextField t8;
+ TextField tvoid;
+ TextArea log;
+ Panel p1;
+ Panel p2;
+ Panel p3;
+ Panel p4;
+ double minx;
+ double miny;
+ double maxx;
+ double maxy;
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Arcs.java b/src/main/java/plugins/ragini/voronoidiagram/Arcs.java
new file mode 100644
index 0000000000000000000000000000000000000000..6ed041fd2c09e8d697603eda05ca5c5f126f0dbe
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Arcs.java
@@ -0,0 +1,33 @@
+package plugins.ragini.voronoidiagram;
+
+public class Arcs {
+
+ private int id;
+ private float dist;
+ private Arcs next;
+
+ public void setID(int i) {
+ id = i;
+ }
+
+ public void setDist(float d) {
+ dist = d;
+ }
+
+ public void setNext(Arcs a) {
+ next = a;
+ }
+
+ public Arcs next() {
+ return next;
+ }
+
+ public float dist() {
+ return dist;
+ }
+
+ public int id() {
+ return id;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/ArraySetter.java b/src/main/java/plugins/ragini/voronoidiagram/ArraySetter.java
new file mode 100644
index 0000000000000000000000000000000000000000..9c8ae5366085dab827e3af6ef68e156f142f18c9
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/ArraySetter.java
@@ -0,0 +1,17 @@
+package plugins.ragini.voronoidiagram;
+
+public class ArraySetter implements Setter<NVert []> {
+
+ private NVert [] var;
+
+ @Override
+ public void set(NVert [] input) {
+ var = input;
+ }
+
+ @Override
+ public NVert [] get() {
+ return var;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Circ.java b/src/main/java/plugins/ragini/voronoidiagram/Circ.java
new file mode 100644
index 0000000000000000000000000000000000000000..77a21c1f147c1c38fd7f01fd4d0c32bb30441cf3
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Circ.java
@@ -0,0 +1,33 @@
+package plugins.ragini.voronoidiagram;
+
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+public class Circ {
+
+ private Point2D center;
+ private double radius;
+ private Point2D corner;
+ private double width;
+ private Rectangle2D rec;
+
+ public Circ(Point2D c, double r) {
+ center = c;
+ radius = r;
+ width = r*2;
+ corner = new Point2D.Double(center.getX()-r, center.getY()-r);
+ rec = new Rectangle2D.Double(corner.getX(), corner.getY(), width, width);
+ }
+
+ public double r() {
+ return radius;
+ }
+
+ public Rectangle2D rectangle() {
+ return rec;
+ }
+
+ //private float cx, cy, r;
+ //private int nbr1, nbr2, nbr3;
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Constants.java b/src/main/java/plugins/ragini/voronoidiagram/Constants.java
new file mode 100644
index 0000000000000000000000000000000000000000..8c296c9e235438de2ff385cf383846ed7ea6003a
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Constants.java
@@ -0,0 +1,377 @@
+package plugins.ragini.voronoidiagram;
+
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+
+public class Constants {
+
+ private int maxSites;
+ private int le;
+ private int re;
+ private int maxVerts;
+ private int maxEdges;
+ private int maxTris;
+ private int triangulate;
+ private int rng;
+ private int vrdebug;
+
+ private float vxmin, vxmax, vymin, vymax, vdeltax, vdeltay;
+
+ private Vert[] GLsites, USites, verts;
+ private EdgeS[] vedges;
+ private Tri[] tris;
+ private Tri[] dtris;
+
+ private NVert[] chverts, uchverts;
+ private Neighbor [] _sites;
+ private int nsites;
+ private Point2D [][] lines;
+ private int lineindex;
+
+ private int lbnd;
+ private int bbnd;
+ private int rbnd;
+ private int tbnd;
+ private int PQhashsize;
+ private int nedges;
+
+ private Site bottomsite;
+ private double sqrt_nsites;
+
+ private int edgex;
+ private int edgey;
+ private int maxbinx;
+ private int maxbiny;
+
+ private ArrayList<EdgeRNG> relativeneighbors;
+
+ public Constants() {
+ maxSites = 2*4096;
+ le = 0;
+ re = 1;
+ maxVerts = 3*maxSites;
+ maxEdges = 2*maxSites;
+ maxTris = maxEdges;
+ verts = new Vert[maxVerts];
+ vedges = new EdgeS[maxEdges];
+ tris = new Tri[maxTris];
+ chverts = new NVert[maxVerts];
+ uchverts = new NVert[maxVerts];
+ lbnd = 0;
+ bbnd = 1;
+ rbnd = 2;
+ tbnd = 3;
+ triangulate = 0;
+ rng = 0;
+ vrdebug = 0;
+ lineindex = 0;
+ }
+
+ public Vert[] getGLSites() {
+ //System.out.println("retrieving GLsites");
+ return GLsites;
+ }
+
+ public int le() {
+ //System.out.println("retrieving le");
+ return le;
+ }
+
+ public int re() {
+ //System.out.println("retrieving re");
+ return re;
+ }
+
+ public int nsites() {
+ //System.out.println("retrieving nsites");
+ return nsites;
+ }
+
+ public void setNSites(int n) {
+ //System.out.println("setting nsites");
+ nsites = n;
+ lines = new Point2D[n*3][2];
+ }
+
+ public NVert[] chverts() {
+ //System.out.println("retrieving chverts");
+ return chverts;
+ }
+
+ public int triangulate() {
+ //System.out.println("retrieving triangulate");
+ return triangulate;
+ }
+
+ public EdgeS[] vedges() {
+ //System.out.println("retrieving vedges");
+ return vedges;
+ }
+
+ public int vrdebug() {
+ //System.out.println("retrieving vrdebug");
+ return vrdebug;
+ }
+
+ public int maxEdges() {
+ //System.out.println("retrieving maxedges");
+ return maxEdges;
+ }
+
+ public Vert[] verts() {
+ //System.out.println("retrieving verts");
+ return verts;
+ }
+
+ public int maxVerts() {
+ //System.out.println("retrieving maxverts");
+ return maxVerts;
+ }
+
+ public int maxTris() {
+ //System.out.println("retrieving maxtris");
+ return maxTris;
+ }
+
+ public Tri[] tris() {
+ //System.out.println("retrieving tris");
+ return tris;
+ }
+
+ public Tri[] dtris() {
+ //System.out.println("retrieving dtris");
+ return dtris;
+ }
+
+ public void setdtris(Tri [] _dtris) {
+ //System.out.println("setting dtris");
+ dtris = _dtris;
+ }
+
+ public Neighbor[] sites() {
+ //System.out.println("retrieving sites");
+ return _sites;
+ }
+
+ public int maxSites() {
+ //System.out.println("retrieving maxsites");
+ return maxSites;
+ }
+
+ public Vert[] USites() {
+ //System.out.println("retrieving usites");
+ return USites;
+ }
+
+ public NVert[] uchverts() {
+ //System.out.println("retrieving uchverts");
+ return uchverts;
+ }
+
+ public void setTriangulate(int n) {
+ //System.out.println("setting triangulate");
+ triangulate = n;
+ }
+
+ public int lbnd() {
+ //System.out.println("retrieving lbnd");
+ return lbnd;
+ }
+
+ public int bbnd() {
+ //System.out.println("retrieving bbnd");
+ return bbnd;
+ }
+
+ public int rbnd() {
+ //System.out.println("retrieving rbnd");
+ return rbnd;
+ }
+
+ public int tbnd() {
+ //System.out.println("retrieving tbnd");
+ return tbnd;
+ }
+
+ public void setvxmin(float m) {
+ //System.out.println("setting vxmin");
+ vxmin = m;
+ }
+
+ public void setvxmax(float m) {
+ //System.out.println("setting vxmax");
+ vxmax = m;
+ }
+
+ public void setvymin(float m) {
+ //System.out.println("setting vymin");
+ vymin = m;
+ }
+
+ public void setvymax(float m) {
+ //System.out.println("setting vymax");
+ vymax = m;
+ }
+
+ public float vxmin() {
+ //System.out.println("retrieving vxmin");
+ return vxmin;
+ }
+
+ public float vxmax() {
+ //System.out.println("retrieving vxmax");
+ return vxmax;
+ }
+
+ public float vymin() {
+ //System.out.println("retrieving vymin");
+ return vymin;
+ }
+
+ public float vymax() {
+ //System.out.println("retrieving vymax");
+ return vymax;
+ }
+
+ public float vdeltax() {
+ //System.out.println("retrieving vdeltax");
+ return vdeltax;
+ }
+
+ public void setBottomSite(Site s) {
+ //System.out.println("setting bottomsite");
+ bottomsite = s;
+ }
+
+ public Site bottomsite() {
+ //System.out.println("retrieving bottomsite");
+ return bottomsite;
+ }
+
+ public void setTris(Tri[] tri) {
+ //System.out.println("setting tris");
+ tris = tri;
+ }
+
+ public void setvdeltax(float d) {
+ //System.out.println("setting vdeltax");
+ vdeltax = d;
+ }
+
+ public void setvdeltay(float d) {
+ //System.out.println("setting vdeltay");
+ vdeltay = d;
+ }
+
+ public int nedges() {
+ //System.out.println("retrieving nedges");
+ return nedges;
+ }
+
+ public void setnedges(int n) {
+ //System.out.println("setting nedges");
+ nedges = n;
+ }
+
+ public int PQhashsize() {
+ //System.out.println("retrieving pqhashsize");
+ return PQhashsize;
+ }
+
+ public float vdeltay() {
+ //System.out.println("retrieving vdeltay");
+ return vdeltay;
+ }
+
+ public void setsqrtnsites(double n) {
+ //System.out.println("setting sqrtnsites");
+ sqrt_nsites = n;
+ }
+
+ public double sqrtnsites() {
+ //System.out.println("retrieving sqrtnsites");
+ return sqrt_nsites;
+ }
+
+ public void setPQhashsize(int n) {
+ PQhashsize = n;
+ }
+
+ public void setchverts (NVert[] varray) {
+ chverts = varray;
+ }
+
+ public void setUSites(Vert[] sites) {
+ USites = sites;
+ }
+
+ public void setGLsites(Vert[] sites) {
+ GLsites = sites;
+ }
+
+ public void setSites(Neighbor[] sites){
+ _sites = sites;
+ }
+
+ public Point2D[][] lines() {
+ return lines;
+ }
+
+ public void setlineindex(int n) {
+ lineindex = n;
+ }
+
+ public int lineindex() {
+ return lineindex;
+ }
+
+ public int rng() {
+ return rng;
+ }
+
+ public void setrng(int r) {
+ rng = r;
+ }
+
+ public int getedgex() {
+ return edgex;
+ }
+
+ public int getedgey() {
+ return edgey;
+ }
+
+ public void setedgex(int n) {
+ edgex = n;
+ }
+
+ public void setedgey(int n) {
+ edgey = n;
+ }
+
+ public int maxbinx() {
+ return maxbinx;
+ }
+
+ public int maxbiny() {
+ return maxbiny;
+ }
+
+ public void setmaxbinx(int b) {
+ maxbinx = b;
+ }
+
+ public void setmaxbiny(int b) {
+ maxbiny = b;
+ }
+
+ public ArrayList<EdgeRNG> relativeneighbors() {
+ return relativeneighbors;
+ }
+
+ public void setrelativeneighbors(ArrayList<EdgeRNG> l) {
+ relativeneighbors = l;
+ }
+}
+
+
diff --git a/src/main/java/plugins/ragini/voronoidiagram/DT.java b/src/main/java/plugins/ragini/voronoidiagram/DT.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ccd14fd6a6c49af00d2c09492fc9a013d874ffd
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/DT.java
@@ -0,0 +1,50 @@
+package plugins.ragini.voronoidiagram;
+
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: DT.java
+
+//Referenced classes of package delaunay:
+// Vertex, Face
+
+public class DT
+{
+
+ public DT()
+ {
+ }
+
+ public static int nextCoord(int i)
+ {
+ return i != 0 ? 0 : 1;
+ }
+
+ public static final int XAXIS = 0;
+ public static final int YAXIS = 1;
+ public static final int ZAXIS = 2;
+ public static final int ALG_INCODE = 0;
+ public static final int ALG_DEWALL = 1;
+ public static final int ALG_GUIBAS = 2;
+ public static int counter1;
+ public static int counter2;
+ public static int counter3;
+ public static float opacity = 1.0F;
+ public static int type = 1;
+ public static int step = 40;
+ public static double res = 1.0D;
+ public static double jitter = 0.01D;
+ public static double MAX_VALUE;
+ public static double densityParameter = 0.5D;
+ public static Vertex vertexAngle = new Vertex(-1D, -1D);
+ public static int frame;
+ public static Face face_null = new Face();
+ public static Vertex vertex_null = new Vertex(0.0D, 0.0D);
+ public static Vertex vertex_infty;
+
+ static
+ {
+ MAX_VALUE = 100000D;
+ vertex_infty = new Vertex(MAX_VALUE, MAX_VALUE);
+ }
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Delaunay.java b/src/main/java/plugins/ragini/voronoidiagram/Delaunay.java
new file mode 100644
index 0000000000000000000000000000000000000000..81c931c9ba91a042417511788ef325a9c35cf9ea
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Delaunay.java
@@ -0,0 +1,121 @@
+package plugins.ragini.voronoidiagram;
+
+public class Delaunay {
+
+ public Arcs InitArcD() {
+ Arcs item;
+
+ item = new Arcs();
+ item.setNext(null);
+ item.setID(-1);
+ item.setDist(-1);
+ return item;
+
+ }
+
+ public void AddArc(Arcs IVert, int v2, float dist, IntSetter nset) {
+ Arcs item = InitArcD();
+ Arcs courant; //does n always have to get set only to 1?
+
+ item.setID(v2);
+ item.setDist(dist);
+
+ if (IVert.next() == null) {
+ IVert.setNext(item);
+ nset.set(1);
+ }
+ else {
+ courant = IVert.next();
+ if (courant.dist() > dist) {
+ IVert.setNext(item);
+ item.setNext(courant);
+ nset.set(1);
+ }
+ else {
+ while ((courant.next()!=null) && (courant.next().dist() <= dist) && (courant.id() != v2)) {
+ courant = courant.next();
+ }
+ if (courant.id() != v2) {
+ item.setNext(courant.next());
+ courant.setNext(item);
+ nset.set(1);
+ }
+ }
+ }
+ }
+
+ public GraphD [] InitGDelaunay(int n) {
+ GraphD [] item;
+ int i;
+
+ item = new GraphD [n];
+ for(i = 0; i < n; i++) {
+ item[i].setArcs(null);
+ item[i].setNbArcs((short) 0);
+ }
+ return item;
+ }
+
+ public void InsertArc(GraphD[] Graph, int Vertice1, int Vertice2) {
+ float dist;
+ float min;
+ Arcs IVert, Courant, Item;
+ int n = 0;
+ IntSetter nset = new IntSetter(n);
+
+ dist = (float) Math.sqrt((Graph[Vertice1].pt().X() - Graph[Vertice2].pt().X()) * (Graph[Vertice1].pt().X()-Graph[Vertice2].pt().X()) + (Graph[Vertice1].pt().Y() - Graph[Vertice2].pt().Y()) * (Graph[Vertice1].pt().Y()- Graph[Vertice2].pt().Y()));
+ if (Graph[Vertice1].arcs() == null) {
+ IVert = InitArcD();
+
+ AddArc(IVert, Vertice2, dist, nset);
+ n = nset.get();
+ Graph[Vertice1].setArcs(IVert);
+ Graph[Vertice1].setNbArcs((short) (Graph[Vertice1].nbarcs() + n)); //does this cast work?
+ }
+ else {
+ IVert = Graph[Vertice1].arcs();
+
+ if (IVert.next().dist() > dist) {
+ Item = InitArcD();
+ Item.setID(Vertice2);
+ Item.setDist(dist);
+ Item.setNext(IVert.next());
+ Graph[Vertice1].setNbArcs((short) (Graph[Vertice1].nbarcs() + 1));
+ Graph[Vertice1].arcs().setNext(Item);
+ }
+ else {
+ AddArc(IVert, Vertice2, dist, nset); //or, maybe could have it return the number of new arcs?
+ n = nset.get();
+ Graph[Vertice1].setNbArcs((short) (Graph[Vertice1].nbarcs() + n));
+ }
+ }
+
+ if(Graph[Vertice2].arcs() == null) {
+ IVert = InitArcD();
+ AddArc(IVert, Vertice1, dist, nset);
+ n = nset.get();
+ Graph[Vertice2].setNbArcs((short) (Graph[Vertice1].nbarcs() + n));
+ Graph[Vertice2].setArcs(IVert);
+ }
+ else {
+ IVert = Graph[Vertice2].arcs();
+
+ if (IVert.next().dist() > dist) {
+ Courant = IVert;
+ Item = InitArcD();
+ Item.setID(Vertice1);
+ Item.setDist(dist);
+ Item.setNext(IVert.next());
+ Graph[Vertice2].setNbArcs((short) (Graph[Vertice1].nbarcs() + 1));
+ Graph[Vertice2].arcs().setNext(Item);
+ }
+ else {
+ AddArc(IVert, Vertice1, dist, nset);
+ n = nset.get();
+ Graph[Vertice2].setNbArcs((short) (Graph[Vertice1].nbarcs() + n));
+ }
+ }
+
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/DelaunayTriangulator.java b/src/main/java/plugins/ragini/voronoidiagram/DelaunayTriangulator.java
new file mode 100644
index 0000000000000000000000000000000000000000..b35b7da00e4cc592c3504a45aaa3934040313984
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/DelaunayTriangulator.java
@@ -0,0 +1,581 @@
+package plugins.ragini.voronoidiagram;
+
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: DelaunayTriangulator.java
+
+import java.io.PrintStream;
+import java.util.*;
+
+//Referenced classes of package delaunay:
+// DT, Face, QuadEdge, AFL,
+// UniformGrid, Display, Vertex
+
+public class DelaunayTriangulator
+{
+
+ public DelaunayTriangulator()
+ {
+ faces = new Vector();
+ edges = new Vector();
+ radiusMean = 0.0D;
+ DT.counter1 = 0;
+ DT.counter2 = 0;
+ DT.counter3 = 0;
+ }
+
+ public void resetAll()
+ {
+ faces.clear();
+ edges.clear();
+ radiusMean = 0.0D;
+ DT.counter1 = 0;
+ DT.counter2 = 0;
+ DT.counter3 = 0;
+ }
+
+ private void ajouterFace(Face f)
+ {
+ faces.addElement(f);
+ DT.counter3++;
+ }
+
+ public Enumeration extractFaces()
+ {
+ return faces.elements();
+ }
+
+ public Vector getFaces()
+ {
+ return faces;
+ }
+
+ public void setMeasure()
+ {
+ Enumeration listing = extractFaces();
+ Vector auxV = new Vector();
+ double measureMean = 0.0D;
+ int count = 0;
+ while(listing.hasMoreElements())
+ {
+ Face f = (Face)listing.nextElement();
+ double rad = f.getMeasure();
+ if(rad < DT.MAX_VALUE)
+ {
+ count++;
+ auxV.add(new Double(rad));
+ measureMean += rad;
+ }
+ }
+ double aux[] = new double[auxV.size()];
+ for(int i = 0; i < count; i++)
+ aux[i] = ((Double)auxV.get(i)).doubleValue();
+
+ Arrays.sort(aux);
+ measureMedian = aux[count / 2];
+ this.measureMean = measureMean / (double)count;
+ }
+
+ public void setRadius()
+ {
+ Enumeration listing = extractFaces();
+ Vector auxV = new Vector();
+ double radiusMean = 0.0D;
+ int count = 0;
+ while(listing.hasMoreElements())
+ {
+ Face f = (Face)listing.nextElement();
+ double rad = f.getInvRadius();
+ if(rad < DT.MAX_VALUE)
+ {
+ count++;
+ auxV.add(new Double(rad));
+ radiusMean += rad;
+ }
+ }
+ double aux[] = new double[auxV.size()];
+ for(int i = 0; i < count; i++)
+ aux[i] = ((Double)auxV.get(i)).doubleValue();
+
+ Arrays.sort(aux);
+ radiusMedian = aux[count / 2];
+ this.radiusMean = radiusMean / (double)count;
+ }
+
+ public void setSize()
+ {
+ Enumeration listing = extractFaces();
+ Vector auxV = new Vector();
+ double sizeMean = 0.0D;
+ int count = 0;
+ while(listing.hasMoreElements())
+ {
+ Face f = (Face)listing.nextElement();
+ double size = f.getInvSize();
+ if(size < DT.MAX_VALUE)
+ {
+ count++;
+ auxV.add(new Double(size));
+ sizeMean += size;
+ }
+ }
+ double aux[] = new double[auxV.size()];
+ for(int i = 0; i < count; i++)
+ aux[i] = ((Double)auxV.get(i)).doubleValue();
+
+ Arrays.sort(aux);
+ sizeMedian = aux[count / 2];
+ this.sizeMean = sizeMean / (double)count;
+ }
+
+ public double getRadiusMean()
+ {
+ return radiusMean;
+ }
+
+ public double getRadiusMedian()
+ {
+ return radiusMedian;
+ }
+
+ public double getSizeMean()
+ {
+ return sizeMean;
+ }
+
+ public double getSizeMedian()
+ {
+ return sizeMedian;
+ }
+
+ public double getMeasureMean()
+ {
+ return measureMean;
+ }
+
+ public double getMeasureMedian()
+ {
+ return measureMedian;
+ }
+
+ public double getThresholdOpt()
+ {
+ return measureMedian * DT.densityParameter;
+ }
+
+ public Vector getEdges()
+ {
+ return edges;
+ }
+
+ public Enumeration extractEdges()
+ {
+ return edges.elements();
+ }
+
+ private void extractEdges(QuadEdge edge)
+ {
+ DT.counter1 = 0;
+ extractEdges(edge, 0x7fffffff);
+ edges.clear();
+ Stack stk = new Stack();
+ int counter = -1;
+ stk.push(edge);
+ while(!stk.isEmpty())
+ {
+ QuadEdge e = (QuadEdge)stk.pop();
+ if(e.getCounter() != counter)
+ {
+ DT.counter1++;
+ if(e.isCanonical())
+ edges.add(e);
+ else
+ edges.add(e.sym());
+ }
+ e.setCounter(counter);
+ e.sym().setCounter(counter);
+ if(e.onext().getCounter() != counter)
+ stk.push(e.onext());
+ if(e.sym().onext().getCounter() != counter)
+ stk.push(e.sym().onext());
+ }
+ }
+
+ public Enumeration extractEdges(QuadEdge edge, int counter)
+ {
+ Vector edges = new Vector();
+ Stack stk = new Stack();
+ stk.push(edge);
+ while(!stk.isEmpty())
+ {
+ QuadEdge e = (QuadEdge)stk.pop();
+ if(e.getCounter() < counter)
+ if(e.isCanonical())
+ edges.add(e);
+ else
+ edges.add(e.sym());
+ e.setCounter(counter);
+ e.sym().setCounter(counter);
+ if(e.onext().getCounter() < counter)
+ stk.push(e.onext());
+ if(e.sym().onext().getCounter() < counter)
+ stk.push(e.sym().onext());
+ }
+ return edges.elements();
+ }
+
+ private QuadEdge putEdge(QuadEdge e, double med, int coord, AFL left, AFL center, AFL right)
+ {
+ int i = e.type(med, coord);
+ QuadEdge qe;
+ if(i < 0)
+ qe = left.putTest(e);
+ else
+ if(i == 0)
+ qe = center.putTest(e);
+ else
+ qe = right.putTest(e);
+ return qe;
+ }
+
+ public QuadEdge inCoDeTotal(Display disp, Vertex sites[], Vertex sitesBin[])
+ {
+ QuadEdge tri = inCoDe(disp, sites);
+ extractEdges(tri);
+ constructDual();
+ return tri;
+ }
+
+ public QuadEdge inCoDe(Display disp, Vertex sites[])
+ {
+ UniformGrid grid = new UniformGrid(sites, sites.length);
+ AFL list = new AFL();
+ AFL list_aux = new AFL();
+ System.out.println("Debut inCode");
+ disp.setQuadEdge(null);
+ disp.setRange(0.0D, 0.0D, 1.0D, 1.0D);
+ disp.setCenterAFL(list);
+ disp.setTriangles(faces);
+ disp.setEdges(edges);
+ disp.breakBig();
+ int count = 0;
+ Vertex seed = new Vertex(grid.XMin() + grid.XSize() / 2D, grid.YMin() + grid.YSize() / 2D);
+ Vertex A = grid.findNearestPoint(seed);
+ Vertex B = grid.findNearestPoint(A);
+ Vertex C = grid.findDelaunayPoint(A, B);
+ if(C == null)
+ C = grid.findDelaunayPoint(B, A);
+ if(C == null)
+ return QuadEdge.makeEdge(A, B);
+ Vertex S = Vertex.findCenter(A, B, C);
+ double rad = Vertex.distance(S, A);
+ disp.setCircle(S, rad);
+ disp.setTriangle(A, B, C);
+ if(Vertex.ccw(A, B, C))
+ {
+ Vertex pom = B;
+ B = C;
+ C = pom;
+ }
+ QuadEdge a = QuadEdge.makeEdge(A, B);
+ QuadEdge b = QuadEdge.makeEdge(B, C);
+ a.sym().splice(b);
+ QuadEdge c = QuadEdge.connect(b, a);
+ QuadEdge tri = a;
+ disp.setQuadEdge(tri);
+ list.put(a);
+ list.put(b);
+ list.put(c);
+ Face f = new Face(a, b, c);
+ ajouterFace(f);
+ a.setFace(f);
+ b.setFace(f);
+ c.setFace(f);
+ disp.breakBig();
+ for(; !list.isEmpty(); disp.breakBig())
+ {
+ count++;
+ a = list.extract();
+ QuadEdge olda = list_aux.putTest(a);
+ if(olda != null)
+ System.out.println("InCode deja traite");
+ A = a.orig();
+ B = a.dest();
+ C = grid.findDelaunayPoint(A, B);
+ if(C != null && olda == null)
+ {
+ S = Vertex.findCenter(A, B, C);
+ rad = Vertex.distance(S, A);
+ disp.setCircle(S, rad);
+ disp.setTriangle(A, B, C);
+ b = QuadEdge.makeEdge(A, C);
+ c = QuadEdge.makeEdge(C, B);
+ f = null;
+ QuadEdge oldb = list.putTest(b);
+ QuadEdge oldc = list.putTest(c);
+ if(oldb == null && oldc == null)
+ {
+ a.splice(b);
+ a.lnext().splice(c.sym());
+ b.sym().splice(c);
+ f = new Face(a.sym(), b, c);
+ b.setFace(f);
+ c.setFace(f);
+ } else
+ if(oldb == null)
+ {
+ a.splice(b);
+ if(oldc.lnext() != b.sym())
+ oldc.lnext().splice(b.sym());
+ if(oldc.onext() != a.sym())
+ {
+ oldc.lnext().splice2(b.lnext());
+ oldc.splice2(a.sym());
+ }
+ f = new Face(a.sym(), b, oldc.sym());
+ b.setFace(f);
+ oldc.sym().setFace(f);
+ } else
+ if(oldc == null)
+ {
+ if(a.lnext() != c.sym())
+ a.lnext().splice(c.sym());
+ oldb.splice(c);
+ if(a.onext() != oldb.sym())
+ {
+ oldb.lnext().splice2(a.sym().rprev());
+ a.splice2(oldb.sym());
+ }
+ f = new Face(a.sym(), oldb.sym(), c);
+ oldb.sym().setFace(f);
+ c.setFace(f);
+ } else
+ {
+ if(a.onext() != oldb.sym())
+ a.splice2(oldb.sym());
+ if(oldb.onext() != oldc.sym())
+ {
+ oldc.lnext().splice2(oldb.sym().rprev());
+ oldb.splice2(oldc.sym());
+ }
+ f = new Face(a.sym(), oldb.sym(), oldc.sym());
+ oldb.sym().setFace(f);
+ oldc.sym().setFace(f);
+ }
+ a.sym().setFace(f);
+ ajouterFace(f);
+ }
+ }
+
+ disp.setCircle(null, 0.0D);
+ disp.setTriangle(null, null, null);
+ System.out.println((new StringBuilder("Fin inCode : ")).append(count).append(" passages\n").toString());
+ return tri;
+ }
+
+ private void constructDual()
+ {
+ for(Enumeration listing = extractEdges(); listing.hasMoreElements();)
+ {
+ QuadEdge e = (QuadEdge)listing.nextElement();
+ QuadEdge r = e.rot();
+ r.setData(e.rightFace().getBary());
+ if(e.sym().rightFace() != null)
+ r.sym().setData(e.sym().rightFace().getBary());
+ }
+
+ }
+
+ private void setFacesV8_bin(Vertex sitesBin[])
+ {
+ Enumeration listing = extractFaces();
+ if(sitesBin.length == 0)
+ {
+ double alpha = getThresholdOpt();
+ while(listing.hasMoreElements())
+ {
+ Face f = (Face)listing.nextElement();
+ if(f.getMeasure() > alpha)
+ f.setVal(1.0F);
+ else
+ f.setVal(0.0F);
+ }
+ } else
+ {
+ while(listing.hasMoreElements())
+ {
+ Face f = (Face)listing.nextElement();
+ f.setVal(0.0F);
+ for(int i = 0; i < sitesBin.length; i++)
+ if(f.contains(sitesBin[i]) == 1)
+ f.setVal(1.0F);
+
+ }
+ }
+ }
+
+ private void setFacesV8_erode()
+ {
+ float e;
+ Face f;
+ for(Enumeration listing = extractFaces(); listing.hasMoreElements(); f.setValAux(e))
+ {
+ e = 1.0F;
+ f = (Face)listing.nextElement();
+ for(Iterator iter = f.extractFacesVoisines(); iter.hasNext();)
+ {
+ Face ff = (Face)iter.next();
+ e = Math.min(e, ff.getVal());
+ }
+
+ }
+
+ for(Enumeration listing = extractFaces(); listing.hasMoreElements(); f.setVal(f.getValAux()))
+ f = (Face)listing.nextElement();
+
+ }
+
+ private void setFacesV8_dilate(double angle, double epsilon, int ordre)
+ {
+ float e;
+ Face f;
+ for(Enumeration listing = extractFaces(); listing.hasMoreElements(); f.setValAux(e))
+ {
+ e = 0.0F;
+ f = (Face)listing.nextElement();
+ for(Iterator iter = f.extractFacesVoisines(angle, epsilon); iter.hasNext();)
+ {
+ Face ff = (Face)iter.next();
+ e = Math.max(e, Math.max(f.getVal(), (ff.getVal() + (1.0F - (float)ordre / (float)DT.step)) - 1.0F));
+ }
+
+ }
+
+ for(Enumeration listing = extractFaces(); listing.hasMoreElements(); f.setVal(f.getValAux()))
+ f = (Face)listing.nextElement();
+
+ }
+
+ private void setEdgesV8()
+ {
+ for(Enumeration listing = extractEdges(); listing.hasMoreElements();)
+ {
+ QuadEdge e = (QuadEdge)listing.nextElement();
+ if(e.sym().rightFace() != null)
+ {
+ e.setLambda(Math.min(e.rightFace().getVal(), e.sym().rightFace().getVal()));
+ e.setMu(Math.max(e.rightFace().getVal(), e.sym().rightFace().getVal()));
+ e.sym().setLambda(Math.min(e.rightFace().getVal(), e.sym().rightFace().getVal()));
+ e.sym().setMu(Math.max(e.rightFace().getVal(), e.sym().rightFace().getVal()));
+ } else
+ {
+ e.setLambda(1.0F - e.rightFace().getVal());
+ e.setMu(e.rightFace().getVal());
+ e.sym().setLambda(1.0F - e.rightFace().getVal());
+ e.sym().setMu(e.rightFace().getVal());
+ }
+ }
+
+ }
+
+ public void constructBin(Vertex sitesBin[])
+ {
+ setFacesV8_bin(sitesBin);
+ setEdgesV8();
+ }
+
+ public void constructErode()
+ {
+ setFacesV8_erode();
+ setEdgesV8();
+ }
+
+ public void constructDilate(double angle, double epsilon)
+ {
+ setFacesV8_dilate(angle, epsilon, 0);
+ setEdgesV8();
+ }
+
+ public void constructFuzzyDilate(double angle, double epsilon)
+ {
+ for(int k = 0; k < DT.step + 1; k++)
+ setFacesV8_dilate(angle, epsilon, k);
+
+ setEdgesV8();
+ }
+
+ public void constructInter(DelaunayTriangulator dt1, DelaunayTriangulator dt2)
+ {
+ Enumeration listing = extractFaces();
+ Enumeration listing1 = dt1.extractFaces();
+ Face f;
+ Face f1;
+ Face f2;
+ for(Enumeration listing2 = dt2.extractFaces(); listing.hasMoreElements() && listing1.hasMoreElements() && listing2.hasMoreElements(); f.setVal(Math.min(f1.getVal(), f2.getVal())))
+ {
+ f = (Face)listing.nextElement();
+ f1 = (Face)listing1.nextElement();
+ f2 = (Face)listing2.nextElement();
+ }
+
+ setEdgesV8();
+ }
+
+ public void constructUnion(DelaunayTriangulator dt1, DelaunayTriangulator dt2)
+ {
+ Enumeration listing = extractFaces();
+ Enumeration listing1 = dt1.extractFaces();
+ Face f;
+ Face f1;
+ Face f2;
+ for(Enumeration listing2 = dt2.extractFaces(); listing.hasMoreElements() && listing1.hasMoreElements() && listing2.hasMoreElements(); f.setVal(Math.max(f1.getVal(), f2.getVal())))
+ {
+ f = (Face)listing.nextElement();
+ f1 = (Face)listing1.nextElement();
+ f2 = (Face)listing2.nextElement();
+ }
+
+ setEdgesV8();
+ }
+
+ public void constructComp()
+ {
+ Face f;
+ for(Enumeration listing = extractFaces(); listing.hasMoreElements(); f.setVal(1.0F - f.getVal()))
+ f = (Face)listing.nextElement();
+
+ setEdgesV8();
+ }
+
+ public void expliciter()
+ {
+ Enumeration listing = extractEdges();
+ System.out.println((new StringBuilder("Enumeration des ")).append(getEdges().size()).append(" edges ").toString());
+ QuadEdge e;
+ for(; listing.hasMoreElements(); e.expliciter())
+ {
+ e = (QuadEdge)listing.nextElement();
+ System.out.println((new StringBuilder()).append(e).append(" Associ\357\277\275 aux triangles ").append(e.rightFace()).append(" ").append(e.sym().rightFace()).toString());
+ }
+
+ listing = extractFaces();
+ System.out.println((new StringBuilder("Enumeration des ")).append(getFaces().size()).append(" faces").toString());
+ Face f;
+ for(; listing.hasMoreElements(); f.extractFacesVoisines())
+ {
+ f = (Face)listing.nextElement();
+ System.out.println(f);
+ }
+
+ }
+
+ private Vector faces;
+ private Vector edges;
+ private double radiusMean;
+ private double radiusMedian;
+ private double measureMean;
+ private double measureMedian;
+ private double sizeMean;
+ private double sizeMedian;
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Display.java b/src/main/java/plugins/ragini/voronoidiagram/Display.java
new file mode 100644
index 0000000000000000000000000000000000000000..497769d2526a6e765526dbabd0d1b97fd3197c90
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Display.java
@@ -0,0 +1,791 @@
+package plugins.ragini.voronoidiagram;
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: Display.java
+
+
+import java.awt.*;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+import java.awt.image.BufferedImage;
+import java.awt.image.RenderedImage;
+import java.io.*;
+import java.util.*;
+import javax.imageio.ImageIO;
+import javax.swing.JFrame;
+import javax.swing.JOptionPane;
+
+//Referenced classes of package delaunay:
+// Vertex, QuadEdge, Face, DT,
+// UniformGrid, DelaunayTriangulator, AFL
+
+public class Display extends Canvas
+ implements MouseListener
+{
+
+ public void dimensionize()
+ {
+ w = getWidth();
+ h = getHeight();
+ ss = Math.min((double)w / xsize, (double)h / ysize);
+ ss_int = Math.min(w, h);
+ setSize(ss_int, ss_int);
+ }
+
+ synchronized void run(int mode)
+ {
+ playmode = mode;
+ stopped = false;
+ }
+
+ synchronized void stop()
+ {
+ stopped = true;
+ }
+
+ void breakSmall()
+ {
+ if(playmode == 1)
+ stopped = true;
+ if(stopped)
+ {
+ repaint();
+ while(stopped) ;
+ }
+ }
+
+ void breakBig()
+ {
+ if(playmode == 1 || playmode == 2)
+ stopped = true;
+ if(stopped)
+ {
+ repaint();
+ while(stopped) ;
+ }
+ }
+
+ Display(DelaunayTriangulator dt)
+ {
+ this.dt = null;
+ ug = null;
+ center = null;
+ left = null;
+ right = null;
+ tri = null;
+ triangles = null;
+ edges = null;
+ S = null;
+ A = null;
+ B = null;
+ C = null;
+ sites = null;
+ Q = null;
+ Q1 = null;
+ Q2 = null;
+ Q3 = null;
+ frame = 1;
+ coord = -1;
+ rank = 1;
+ rank2 = 1;
+ loadImage = false;
+ pts = new Vector();
+ ptsBin = new Vector();
+ canAdd = false;
+ xoff = 0.0D;
+ yoff = 0.0D;
+ xsize = 1.0D;
+ ysize = 1.0D;
+ ss = 1.0D;
+ sx = 1.0D;
+ ssy = 1.0D;
+ x0 = 0;
+ y0 = 0;
+ w = 400;
+ h = 400;
+ ss_int = 1;
+ stopped = false;
+ playmode = 0;
+ enabled = new boolean[19];
+ this.dt = dt;
+ resetAll(true);
+ setBackground(Color.white);
+ addMouseListener(this);
+ dimensionize();
+ }
+
+ public void setRank(int rank)
+ {
+ this.rank = rank;
+ }
+
+ public void setRank2(int rank2)
+ {
+ this.rank2 = rank2;
+ }
+
+ public void addPoint(Vertex v)
+ {
+ if(enabled[18])
+ ptsBin.add(v);
+ else
+ pts.add(v);
+ }
+
+ public void clearPoints()
+ {
+ pts.clear();
+ ptsBin.clear();
+ image = null;
+ loadImage = false;
+ }
+
+ public int numPoints()
+ {
+ return pts.size();
+ }
+
+ public Vertex[] getPoints()
+ {
+ Vertex sites[] = new Vertex[pts.size()];
+ pts.copyInto(sites);
+ return sites;
+ }
+
+ public void setPoints(Vertex sites[])
+ {
+ pts.clear();
+ for(int i = 0; i < sites.length; i++)
+ pts.add(sites[i]);
+
+ }
+
+ public Vertex[] getPointsBin()
+ {
+ Vertex sites[] = new Vertex[ptsBin.size()];
+ ptsBin.copyInto(sites);
+ return sites;
+ }
+
+ public void loadPoints(int n, double oldminx, double oldminy, double oldmaxx,
+ double oldmaxy, Neighbor[] sites)
+ {
+ pts.clear();
+ for(Neighbor s: sites)
+ {
+ double x = s.getCoord().X();
+ double newx = (((x - oldminx) * (1))/(oldmaxx - oldminx));
+ double y = s.getCoord().Y();
+ double newy = (((y - oldminy) * (1))/(oldmaxy - oldminy));
+ pts.add(new Vertex(newx, newy, pts.size()));
+ }
+
+ }
+
+ public void enableAdding(boolean flag)
+ {
+ canAdd = flag;
+ }
+
+ public void mouseClicked(MouseEvent mouseevent)
+ {
+ }
+
+ public void mouseReleased(MouseEvent mouseevent)
+ {
+ }
+
+ public void mouseEntered(MouseEvent mouseevent)
+ {
+ }
+
+ public void mouseExited(MouseEvent mouseevent)
+ {
+ }
+
+ public void mousePressed(MouseEvent e)
+ {
+ e.consume();
+ if(canAdd)
+ {
+ Vertex v = new Vertex((double)(e.getX() - x0) / ss + xoff, (double)(e.getY() - y0) / ss + yoff, pts.size());
+ addPoint(v);
+ setSites(getPoints());
+ repaint();
+ }
+ }
+
+ public void show(int flag)
+ {
+ enabled[flag] = true;
+ }
+
+ public void hide(int flag)
+ {
+ enabled[flag] = false;
+ }
+
+ public void swap(int flag)
+ {
+ if(!enabled[flag])
+ enabled[flag] = true;
+ else
+ enabled[flag] = false;
+ }
+
+ public void setRange(double xo, double yo, double xs, double ys)
+ {
+ xoff = xo;
+ yoff = yo;
+ xsize = xs;
+ ysize = ys;
+ ss = Math.min((double)w / xsize, (double)h / ysize);
+ }
+
+ public void setWindow(int xleft, int yleft, int width, int height)
+ {
+ x0 = xleft;
+ y0 = yleft;
+ w = width;
+ h = height;
+ ss = Math.min((double)w / xsize, (double)h / ysize);
+ }
+
+ int xconv(double x)
+ {
+ return (int)((x - xoff) * ss) + x0;
+ }
+
+ int yconv(double y)
+ {
+ return (int)((y - yoff) * ss) + y0;
+ }
+
+ int dconv(double x)
+ {
+ return (int)(x * ss);
+ }
+
+ public void setCenterAFL(AFL c)
+ {
+ center = c;
+ }
+
+ public void setLeftAFL(AFL l)
+ {
+ left = l;
+ }
+
+ public void setRightAFL(AFL r)
+ {
+ right = r;
+ }
+
+ public void setTriangulation(AFL t)
+ {
+ tri = t;
+ }
+
+ public void setGrid(UniformGrid u)
+ {
+ ug = u;
+ }
+
+ public void setCircle(Vertex c, double r)
+ {
+ S = c;
+ rad = r;
+ }
+
+ public void setTriangle(Vertex a, Vertex b, Vertex c)
+ {
+ A = a;
+ B = b;
+ C = c;
+ }
+
+ public void setSites(Vertex ss[])
+ {
+ sites = ss;
+ }
+
+ public void setSplittingLine(int c, double m)
+ {
+ coord = c;
+ med = m;
+ }
+
+ public void setQuadEdge(QuadEdge q)
+ {
+ Q = q;
+ }
+
+ public void setQuadEdge3(QuadEdge q1, QuadEdge q2, QuadEdge q3)
+ {
+ Q1 = q1;
+ Q2 = q2;
+ Q3 = q3;
+ }
+
+ public void setTriangles(Vector triangles)
+ {
+ this.triangles = triangles;
+ }
+
+ public void setEdges(Vector edges)
+ {
+ this.edges = edges;
+ }
+
+ public void resetAll(boolean flag)
+ {
+ ug = null;
+ center = left = right = null;
+ tri = null;
+ S = null;
+ A = B = C = null;
+ sites = null;
+ coord = -1;
+ Q = null;
+ Q1 = Q2 = Q3 = null;
+ rank = 1;
+ if(flag)
+ {
+ for(int i = 0; i < 19; i++)
+ enabled[i] = false;
+
+ }
+ }
+
+ private void dessineMesh(Graphics g)
+ {
+ float surface = 0.0F;
+ if(enabled[17])
+ {
+ System.out.println("Mode Contour");
+ g.setColor(Color.green);
+ for(Enumeration listing = edges.elements(); listing.hasMoreElements();)
+ {
+ QuadEdge e = (QuadEdge)listing.nextElement();
+ QuadEdge e_sym = e.sym();
+ if(e.getMu() >= 1.0F && e.getLambda() == 0.0F)
+ {
+ float grey = (float)Math.min(1.0D, e.getMu());
+ grey = 1.0F - grey;
+ g.setColor(new Color(grey, grey, grey));
+ Graphics2D g2 = (Graphics2D)g;
+ g2.setStroke(new BasicStroke(3F));
+ g2.drawLine(xconv(e.orig().x), yconv(e.orig().y), xconv(e_sym.orig().x), yconv(e_sym.orig().y));
+ g2.setStroke(new BasicStroke(1.0F));
+ }
+ }
+
+ } else
+ {
+ System.out.println("Mode Region");
+ for(Enumeration listing = triangles.elements(); listing.hasMoreElements();)
+ {
+ Face f = (Face)listing.nextElement();
+ QuadEdge list_edges[] = new QuadEdge[3];
+ list_edges = f.getEdges();
+ int x[] = new int[3];
+ int y[] = new int[3];
+ for(int i = 0; i < 3; i++)
+ {
+ x[i] = xconv(list_edges[i].orig().x);
+ y[i] = yconv(list_edges[i].orig().y);
+ }
+
+ if(f.getVal() > 0.0F && f.getVal() <= 1.0F)
+ {
+ float grey = f.getVal();
+ surface = (float)((double)surface + 1.0D / f.getMeasure());
+ g.setColor(new Color(grey, grey, grey, DT.opacity));
+ g.fillPolygon(x, y, 3);
+ g.setColor(Color.BLACK);
+ g.drawPolygon(x, y, 3);
+ }
+ }
+
+ }
+ System.out.println(surface);
+ }
+
+ public void paint(Graphics g)
+ {
+ dimensionize();
+ getGraphics().setColor(Color.BLACK);
+ getGraphics().drawRect(1, 1, ss_int - 2, ss_int - 2);
+ setWindow(0, 0, w, h);
+ setVisible(true);
+ if(image != null)
+ g.drawImage(image, 0, 0, ss_int, ss_int, this);
+
+ g.setPaintMode();
+ if(triangles != null)
+ dessineMesh(g);
+ if(ug != null && enabled[0])
+ {
+ g.setColor(Color.lightGray);
+ g.fillRect(xconv(ug.XMin()), yconv(ug.YMin()), dconv(ug.XSize()), dconv(ug.YSize()));
+ }
+ if(pts != null && enabled[10])
+ {
+ g.setColor(Color.BLACK);
+ for(int i = 0; i < pts.size(); i++)
+ {
+ Vertex v = (Vertex)pts.elementAt(i);
+ g.drawLine(xconv(v.x), yconv(v.y), xconv(v.x), yconv(v.y));
+ }
+
+ }
+ if(ptsBin != null && (enabled[10] || enabled[8]))
+ {
+ g.setColor(Color.BLACK);
+ for(int i = 0; i < ptsBin.size(); i++)
+ {
+ Vertex v = (Vertex)ptsBin.elementAt(i);
+ g.drawLine(xconv(v.x), yconv(v.y), xconv(v.x), yconv(v.y));
+ }
+
+ }
+ if(sites != null && enabled[8])
+ {
+ g.setColor(Color.BLACK);
+ for(int i = 0; i < sites.length; i++)
+ g.drawLine(xconv(sites[i].x), yconv(sites[i].y), xconv(sites[i].x), yconv(sites[i].y));
+
+ }
+ if(coord >= 0 && ug != null && enabled[9])
+ {
+ g.setColor(Color.blue);
+ if(coord == 0)
+ g.drawLine(xconv(med), yconv(ug.YMin()), xconv(med), yconv(ug.YMax()));
+ else
+ g.drawLine(xconv(ug.XMin()), yconv(med), xconv(ug.XMax()), yconv(med));
+ }
+ if(Q != null && enabled[11])
+ {
+ g.setColor(Color.BLACK);
+ QuadEdge qe;
+ for(Enumeration e = dt.extractEdges(Q, frame++); e.hasMoreElements(); g.drawLine(xconv(qe.orig().x), yconv(qe.orig().y), xconv(qe.dest().x), yconv(qe.dest().y)))
+ qe = (QuadEdge)e.nextElement();
+
+ }
+ if(Q != null && enabled[13])
+ {
+ g.setColor(Color.red);
+ for(Enumeration e = dt.extractEdges(Q, frame++); e.hasMoreElements();)
+ {
+ QuadEdge qr = (QuadEdge)e.nextElement();
+ QuadEdge qe = qr.rot();
+ if(qe.orig() != null && qe.dest() != null)
+ g.drawLine(xconv(qe.orig().x), yconv(qe.orig().y), xconv(qe.dest().x), yconv(qe.dest().y));
+ }
+
+ }
+ if(center != null && enabled[1])
+ {
+ g.setColor(Color.black);
+ for(int i = 0; i < center.size(); i++)
+ {
+ QuadEdge e = center.get(i);
+ g.drawLine(xconv(e.orig().x), yconv(e.orig().y), xconv(e.dest().x), yconv(e.dest().y));
+ }
+
+ }
+ if(left != null && enabled[2])
+ {
+ g.setColor(Color.green);
+ for(int i = 0; i < left.size(); i++)
+ {
+ QuadEdge e = left.get(i);
+ g.drawLine(xconv(e.orig().x), yconv(e.orig().y), xconv(e.dest().x), yconv(e.dest().y));
+ }
+
+ }
+ if(right != null && enabled[3])
+ {
+ g.setColor(Color.green);
+ for(int i = 0; i < right.size(); i++)
+ {
+ QuadEdge e = right.get(i);
+ g.drawLine(xconv(e.orig().x), yconv(e.orig().y), xconv(e.dest().x), yconv(e.dest().y));
+ }
+
+ }
+ if(enabled[12])
+ {
+ System.out.println("OK EDGE3");
+ if(Q1 != null)
+ {
+ g.setColor(Color.green);
+ g.drawLine(xconv(Q1.orig().x), yconv(Q1.orig().y), xconv(Q1.dest().x), yconv(Q1.dest().y));
+ g.drawRect(xconv(0.20000000000000001D * Q1.orig().x + 0.80000000000000004D * Q1.dest().x) - 1, yconv(0.20000000000000001D * Q1.orig().y + 0.80000000000000004D * Q1.dest().y) - 1, 3, 3);
+ }
+ if(Q2 != null)
+ {
+ g.setColor(Color.blue);
+ g.drawLine(xconv(Q2.orig().x), yconv(Q2.orig().y), xconv(Q2.dest().x), yconv(Q2.dest().y));
+ g.drawRect(xconv(0.20000000000000001D * Q2.orig().x + 0.80000000000000004D * Q2.dest().x) - 1, yconv(0.20000000000000001D * Q2.orig().y + 0.80000000000000004D * Q2.dest().y) - 1, 3, 3);
+ }
+ if(Q3 != null)
+ {
+ g.setColor(Color.gray);
+ g.drawLine(xconv(Q3.orig().x), yconv(Q3.orig().y), xconv(Q3.dest().x), yconv(Q3.dest().y));
+ g.drawRect(xconv(0.20000000000000001D * Q3.orig().x + 0.80000000000000004D * Q3.dest().x) - 1, yconv(0.20000000000000001D * Q3.orig().y + 0.80000000000000004D * Q3.dest().y) - 1, 3, 3);
+ }
+ }
+ if(A != null && B != null && C != null && enabled[6])
+ {
+ g.setColor(Color.red);
+ g.drawLine(xconv(A.x), yconv(A.y), xconv(B.x), yconv(B.y));
+ g.drawString("A", xconv(A.x), yconv(A.y));
+ g.setColor(Color.pink);
+ g.drawLine(xconv(B.x), yconv(B.y), xconv(C.x), yconv(C.y));
+ g.drawLine(xconv(C.x), yconv(C.y), xconv(A.x), yconv(A.y));
+ }
+ if(S != null && enabled[5])
+ {
+ g.setColor(Color.red);
+ System.out.println((new StringBuilder("rad ")).append(rad).append(" et S ").append(S).toString());
+ g.drawOval(xconv(S.x - rad), yconv(S.y - rad), dconv(2D * rad), dconv(2D * rad));
+ }
+ }
+
+ public void writeImage(File file)
+ {
+ try
+ {
+ Rectangle r = getBounds();
+ Image image = createImage(r.width, r.height);
+ Graphics g = image.getGraphics();
+ paint(g);
+ ImageIO.write((RenderedImage)image, "png", file);
+ }
+ catch(IOException ioe)
+ {
+ ioe.printStackTrace();
+ }
+ }
+
+ public void writePoints(File file)
+ {
+ String filename = file.toString();
+ String ext = filename.substring(filename.lastIndexOf('.') + 1, filename.length());
+ try
+ {
+ if(ext.equals("txt"))
+ {
+ FileWriter fwriter = new FileWriter(filename);
+ BufferedWriter bw = new BufferedWriter(fwriter);
+ for(int i = 0; i < pts.size(); i++)
+ {
+ bw.write((new StringBuilder(String.valueOf(sites[i].x))).append("\t").append(sites[i].y).toString());
+ bw.newLine();
+ }
+
+ bw.close();
+ } else
+ {
+ ObjectOutputStream obj_out = new ObjectOutputStream(new FileOutputStream(file));
+ try
+ {
+ obj_out.writeObject(pts);
+ obj_out.close();
+ }
+ catch(IOException iox)
+ {
+ System.out.println("File saving error...");
+ iox.printStackTrace();
+ }
+ }
+ }
+ catch(FileNotFoundException fnf)
+ {
+ System.out.println("File not found...");
+ fnf.printStackTrace();
+ }
+ catch(Exception fnf)
+ {
+ System.out.println("Exception...");
+ fnf.printStackTrace();
+ }
+ }
+
+ public void loadImage(File file)
+ {
+ String name = file.getAbsolutePath();
+ image = Toolkit.getDefaultToolkit().getImage(name);
+ loadImage = true;
+ repaint();
+ }
+
+ public void loadImage(Image imp)
+ {
+ image = imp;
+ loadImage = true;
+ repaint();
+ }
+
+ public void convertImage()
+ {
+ Random rand = new Random();
+ if(image != null)
+ {
+ BufferedImage bimage = toBufferedImage(image);
+ int rgbs[] = (int[])null;
+ int w = bimage.getWidth();
+ int h = bimage.getHeight();
+ System.out.println((new StringBuilder("w ")).append(w).append(" h ").append(h).toString());
+ rgbs = new int[w * h];
+ bimage.getRGB(0, 0, w, h, rgbs, 0, w);
+ int mask = 255;
+ int count = 0;
+ for(int i = 0; i < h; i++)
+ {
+ for(int j = 0; j < w; j++)
+ {
+ int rgb = bimage.getRGB(j, i);
+ int rouge = rgb >> 16 & mask;
+ int vert = rgb >> 8 & mask;
+ int bleu = rgb & mask;
+ if(rouge == 255 && bleu == 0 && vert == 0)
+ {
+ int x = (j * this.w) / w;
+ int y = (i * this.h) / h;
+ if(canAdd)
+ {
+ count++;
+ Vertex v = new Vertex((double)(x - x0) / ss + xoff + DT.jitter * rand.nextDouble(), (double)(y - y0) / ss + yoff + DT.jitter * rand.nextDouble(), pts.size());
+ pts.add(v);
+ setSites(getPoints());
+ repaint();
+ }
+ }
+ }
+
+ }
+
+ System.out.println((new StringBuilder(String.valueOf(count))).append(" points.").toString());
+ } else
+ {
+ JOptionPane.showMessageDialog(new JFrame(), "No loaded image. Please use Load Image", "Dialog", 0);
+ }
+ }
+
+ public void loadPoints(Neighbor[] sites)
+ {
+ //resetAll(true);
+ //clearPoints();
+ pts.clear();
+
+ for(Neighbor s: sites)
+ {
+ if (s == null)
+ System.out.println("null");
+ else System.out.println("not null");
+ pts.add(new Vertex(s.getCoord().X(), s.getCoord().Y(), pts.size()));
+ }
+ //setSites(getPoints());
+ //show(8);
+
+ // repaint();
+
+ // enableAdding(true);
+ }
+
+ private BufferedImage toBufferedImage(Image image)
+ {
+ if(image instanceof BufferedImage)
+ return (BufferedImage)image;
+ BufferedImage bimage = null;
+ GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+ try
+ {
+ int transparency = 1;
+ GraphicsDevice gs = ge.getDefaultScreenDevice();
+ GraphicsConfiguration gc = gs.getDefaultConfiguration();
+ bimage = gc.createCompatibleImage(image.getWidth(null), image.getHeight(null), transparency);
+ }
+ catch(HeadlessException headlessexception) { }
+ if(bimage == null)
+ {
+ int type = 1;
+ bimage = new BufferedImage(image.getWidth(null), image.getHeight(null), type);
+ }
+ Graphics g = bimage.createGraphics();
+ g.drawImage(image, 0, 0, null);
+ g.dispose();
+ return bimage;
+ }
+
+ Image image;
+ Graphics2D graphic;
+ DelaunayTriangulator dt;
+ UniformGrid ug;
+ AFL center;
+ AFL left;
+ AFL right;
+ AFL tri;
+ Vector triangles;
+ Vector edges;
+ Vertex S;
+ Vertex A;
+ Vertex B;
+ Vertex C;
+ Vertex sites[];
+ QuadEdge Q;
+ QuadEdge Q1;
+ QuadEdge Q2;
+ QuadEdge Q3;
+ int frame;
+ double rad;
+ double med;
+ int coord;
+ int rank;
+ int rank2;
+ boolean loadImage;
+ Vector pts;
+ Vector ptsBin;
+ boolean canAdd;
+ double xoff;
+ double yoff;
+ double xsize;
+ double ysize;
+ double ss;
+ double sx;
+ double ssy;
+ int x0;
+ int y0;
+ int w;
+ int h;
+ int ss_int;
+ boolean stopped;
+ int playmode;
+ public static final int CONTROL_PLAY = 0;
+ public static final int CONTROL_SHORTSTEP = 1;
+ public static final int CONTROL_LONGSTEP = 2;
+ public static final int GRID = 0;
+ public static final int AFLCENTER = 1;
+ public static final int AFLLEFT = 2;
+ public static final int AFLRIGHT = 3;
+ public static final int TRIANGULATION = 4;
+ public static final int CIRCLE = 5;
+ public static final int TRIANGLE = 6;
+ public static final int EDGE1 = 7;
+ public static final int SITES = 8;
+ public static final int SPLITLINE = 9;
+ public static final int POINTVEC = 10;
+ public static final int QUADEDGE = 11;
+ public static final int QUADEDGE3 = 12;
+ public static final int ROT = 13;
+ public static final int ALPHA = 14;
+ public static final int ERODE = 15;
+ public static final int DILATE = 16;
+ public static final int CONTOUR = 17;
+ public static final int BINARIZE = 18;
+ public static final int DUMMY = 19;
+ boolean enabled[];
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Edge.java b/src/main/java/plugins/ragini/voronoidiagram/Edge.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e522e4718bde96d6535737ff89a6b1d2bdfffaf
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Edge.java
@@ -0,0 +1,51 @@
+package plugins.ragini.voronoidiagram;
+
+public class Edge {
+
+ private float a, b, c;
+ private Site[] ep;
+ private Site[] reg;
+ private int edgenbr;
+
+ public Edge() {
+ ep = new Site[2];
+ reg = new Site[2];
+ }
+
+ public float a() {
+ return a;
+ }
+
+ public float b() {
+ return b;
+ }
+
+ public float c() {
+ return c;
+ }
+
+ public Site[] ep() {
+ return ep;
+ }
+
+ public Site[] reg() {
+ return reg;
+ }
+
+ public void seta(double d) {
+ a = (float) d;
+ }
+
+ public void setb(double d) {
+ b = (float) d;
+ }
+
+ public void setc(double d) {
+ c = (float) d;
+ }
+
+ public void setedgenbr(int n) {
+ edgenbr = n;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/EdgeL.java b/src/main/java/plugins/ragini/voronoidiagram/EdgeL.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ff58ba7f649bf7728601232197a35cfa8d68cc1
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/EdgeL.java
@@ -0,0 +1,8 @@
+package plugins.ragini.voronoidiagram;
+
+public class EdgeL {
+
+ private int id1, id2;
+ private dkmax maxk;
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/EdgeList.java b/src/main/java/plugins/ragini/voronoidiagram/EdgeList.java
new file mode 100644
index 0000000000000000000000000000000000000000..987e6c400d54e8b01f125ea0e2407b648ac0fefd
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/EdgeList.java
@@ -0,0 +1,318 @@
+package plugins.ragini.voronoidiagram;
+
+public class EdgeList {
+
+ private HalfEdge ELleftend, ELrightend;
+ private int ELhashsize;
+ private HalfEdge[] ELhash;
+
+ private Constants constants;
+ private VRegion vregion;
+
+ public EdgeList(Constants _constants, VRegion reg) {
+ constants = _constants;
+ vregion = reg;
+ }
+
+ public HalfEdge leftend() {
+ return ELleftend;
+ }
+
+ public HalfEdge rightend() {
+ return ELrightend;
+ }
+
+ public void ELinitialize() {
+ //System.out.println("initializing edge list");
+ int i;
+ ELhashsize = (int) (2 * constants.sqrtnsites());
+ ELhash = new HalfEdge[ELhashsize];
+ //System.out.println("hash size: " + ELhashsize);
+ for (i = 0; i < ELhashsize; i ++) {
+ ELhash[i] = new HalfEdge(-1);
+ }
+
+ ELleftend = HEcreate(null, 0, -1);
+ ELrightend = HEcreate(null, 0, -1);
+ ELleftend.setLeft(null);
+ ELleftend.setRight(ELrightend);
+ ELrightend.setLeft(ELleftend);
+ ELrightend.setRight(null);
+ ELhash[0] = ELleftend;
+ ELhash[ELhashsize - 1] = ELrightend;
+ }
+
+ public HalfEdge HEcreate(Edge e, int pm, int origin) {
+ //System.out.println("creating new halfedge");
+ HalfEdge answer;
+
+ answer = new HalfEdge(origin);
+ answer.setEdge(e);
+ answer.setPM(pm);
+ answer.setNext(null);
+ answer.setVertex(null);
+ answer.setNull(false);
+ return answer;
+ }
+
+ public void ELinsert(HalfEdge lb, HalfEdge newhe) {
+ //if(lb == null) System.out.println("lb null");
+ //else if (newhe == null) System.out.println("newhe null");
+ //else if (lb.eledge() == null) {System.out.println("lb edge null"); System.out.println("newhe: " + newhe.eledge().a() + ", " + newhe.eledge().b() + ", " + newhe.eledge().c()); }
+ //else System.out.println("inserting: " + newhe.eledge().a() + ", " + newhe.eledge().b() + ", " + newhe.eledge().c() + ", " + "after " + lb.eledge().a() + ", " + lb.eledge().b() + ", " + lb.eledge().c());
+ //System.out.println("inserting halfedge");
+ newhe.setLeft(lb);
+ newhe.setRight(lb.right());
+ //if (lb.right().eledge() == null) System.out.println("the right of lb is null");
+ //else System.out.println(newhe.right().eledge().a() + ", " + newhe.right().eledge().b() + ", " + newhe.right().eledge().c() + " is to the right of: " + newhe.eledge().a() + ", " + newhe.eledge().b() + ", " + newhe.eledge().c());
+ lb.right().setLeft(newhe);
+ lb.setRight(newhe);
+ if (lb == ELrightend) {ELrightend = newhe;}
+ }
+
+ public HalfEdge ELgethash(int b) {
+ HalfEdge he;
+
+ if(b < 0 || b >= ELhashsize) {
+ return null;
+ }
+
+ he = ELhash[b];
+ //System.out.println("trying bucket: " + b);
+ //if (he == null) System.out.println("null at bucket: " + b);
+ if (he.isNull() || !he.isDeleted()) {
+ return he;
+ }
+ /* Hash table points to deleted half edge. Patch as necessary. */
+ ELhash[b] = new HalfEdge(-1);
+ //some memory stuff, may return null
+ return null;
+ }
+
+ public HalfEdge ELleftbnd(Point p) {
+ int i, bucket = 0;
+ HalfEdge he;
+
+ bucket = (int) ((p.X() - constants.vxmin())/constants.vdeltax() * ELhashsize);
+ //System.out.println("bucket: " + bucket);
+ if (bucket < 0)
+ bucket = 0;
+
+ if (bucket >= ELhashsize)
+ bucket = ELhashsize -1;
+
+ he = ELgethash(bucket);
+ if (he.isNull()) {
+ for (i = 1; true; i ++) {
+ //fix this for loop
+ if (ELgethash(bucket - i) != null) {
+ if (!(he = ELgethash(bucket - i)).isNull()) {
+ break;
+ }}
+ if (ELgethash(bucket + i) != null) {
+ if (!(he = ELgethash(bucket + 1)).isNull()) {
+ break;
+ }}
+ }
+
+ }
+
+ if (he == ELleftend) {
+ he = he.right();
+ while (he != ELrightend && right_of(he, p)) {
+ he = he.right();
+ }
+ he = he.left();
+ }
+
+ else if (he != ELrightend ) {
+ if (right_of(he, p)) {
+ he = he.right();
+ while (he != ELrightend && right_of(he, p)) {
+ he = he.right();
+ }
+ he = he.left(); }
+ }
+
+ else {
+ he = he.left();
+ while (he != ELleftend && !right_of(he,p)) {
+ he = he.left();
+ }
+ }
+
+ if (bucket > 0 && bucket < ELhashsize - 1) {
+ if (!ELhash[bucket].isNull())
+ //System.out.println("valid bucket");
+ ELhash[bucket] = he;
+ }
+ return he;
+
+ }
+
+ public boolean right_of(HalfEdge el, Point p) {
+ //returns 1 if p is to the right of halfedge e
+ Edge e;
+ Site topsite;
+ int right_of_site;
+ boolean above, fast;
+ float dxp, dyp, dxs, t1, t2, t3, y1;
+
+ e = el.eledge();
+ topsite = e.reg()[1];
+ right_of_site = (p.X() > topsite.getCoord().X()) ? 1: 0;
+ if (right_of_site == 1 && el.elpm() == constants.le())
+ return true;
+ else if (right_of_site == 0 && el.elpm() == constants.re())
+ return false;
+
+ if (e.a() == 1) {
+ dyp = p.Y() - topsite.getCoord().Y();
+ dxp = p.X() - topsite.getCoord().X();
+ fast = false;
+ if ((right_of_site == 0 & e.b()< 0) | (right_of_site == 1 & e.b()>=0)) {
+ above = (dyp >= e.b()*dxp);
+ fast = above;
+ }
+ else {
+ above = (p.X() + p.Y()*e.b() > e.c());
+ if (e.b() < 0)
+ above = !above;
+ if (!above)
+ fast = true;
+ }
+ if (!fast) {
+ dxs = topsite.getCoord().X() - (e.reg()[0]).getCoord().X();
+ above = ((e.b() * (dxp * dxp - dyp * dyp)) < (dxs * dyp * (1 + 2*dxp/dxs + e.b()*e.b())));
+ if (e.b() < 0)
+ above = !above;
+ }
+ }
+ else { //e.b() == 1
+ y1 = e.c() - e.a()*p.X();
+ t1 = p.Y() - y1;
+ t2 = p.X() - topsite.getCoord().X();
+ t3 = y1 - topsite.getCoord().Y();
+ above = (t1*t1 > (t2*t2 + t3*t3));
+ }
+ return (el.elpm() == constants.le() ? above : !above);
+ }
+
+ public void ELdelete(HalfEdge he) {
+ he.left().setRight(he.right());
+ he.right().setLeft(he.left());
+ he.setEdge(null);
+ he.setDeleted(true);
+ }
+
+ public HalfEdge ELright(HalfEdge he) {
+ return he.right();
+ }
+
+ public HalfEdge ELleft(HalfEdge he) {
+ return he.left();
+ }
+
+ public Neighbor leftReg(HalfEdge he) {
+ if (he.eledge() == null)
+ return (Neighbor) constants.bottomsite();
+ return (Neighbor) (he.elpm() == constants.le() ? he.eledge().reg()[constants.le()] : he.eledge().reg()[constants.re()]);
+ }
+
+ public Neighbor rightReg(HalfEdge he) {
+ if (he.eledge() == null)
+ return (Neighbor) constants.bottomsite();
+ return (Neighbor) (he.elpm() == constants.le() ? he.eledge().reg()[constants.re()] : he.eledge().reg()[constants.le()]);
+ }
+
+ public Edge bisect(Site s1, Site s2) {
+ float dx, dy, adx, ady;
+ Edge newedge;
+ //System.out.println("bisecting:");
+ //System.out.println("s1: " + s1.getCoord().X() + " " + s1.getCoord().Y());
+ //System.out.println("s2: " + s2.getCoord().X() + " " + s2.getCoord().Y());
+
+ newedge = new Edge();
+ newedge.reg()[0] = s1;
+ newedge.reg()[1] = s2;
+ newedge.ep()[0] = null;
+ newedge.ep()[1] = null;
+
+ dx = s2.getCoord().X() - s1.getCoord().X(); //System.out.println("dx: " + dx);
+ dy = s2.getCoord().Y() - s1.getCoord().Y(); //System.out.println("dy: " + dy);
+ adx = dx > 0 ? dx : -dx;
+ ady = dy > 0 ? dy : -dy;
+
+ newedge.setc(s1.getCoord().X() * dx + s1.getCoord().Y() * dy +(dx*dx + dy*dy)*0.5);
+ //newedge.setc((dx*dx + dy*dy)*0.5);
+ if (adx > ady) {
+ newedge.seta(1); //System.out.println("a: " + newedge.a());
+ newedge.setb(dy/dx); //System.out.println("b: " + newedge.b());
+ if (dx == 0) System.out.println("dividing by zero");
+ newedge.setc(newedge.c()/dx); //System.out.println("c: " + newedge.c());
+ }
+ else {
+ newedge.setb(1); //System.out.println("b: " + newedge.b());
+ newedge.seta(dx/dy); //System.out.println("a: " + newedge.a());
+ if (dy == 0) System.out.println("dividing by zero");
+ newedge.setc(newedge.c()/dy); //System.out.println("c: " + newedge.c());
+ }
+ newedge.setedgenbr(constants.nedges());
+ vregion.outBisector(newedge);
+ constants.setnedges(constants.nedges() +1);
+ return newedge;
+ }
+
+ public void v_endpoint(Edge e, int origin, int lr, Site s) {
+ e.ep()[lr] = s;
+ if (e.ep()[constants.re() - lr] == null)
+ return;
+ vregion.outEP(e, origin);
+ }
+
+ public Site sintersect(HalfEdge el1, HalfEdge el2) {
+ Edge e1, e2, e;
+ HalfEdge el;
+
+ float d, xint, yint;
+ int right_of_site;
+ Neighbor v;
+
+ e1 = el1.eledge();
+ e2 = el2.eledge();
+
+ if (e1 == null || e2 == null)
+ return null;
+
+ if (e1.reg()[1] == e2.reg()[1])
+ return null;
+
+ d = e1.a() * e2.b() - e1.b()*e2.a();
+ if (d==0) return null;
+ if ((-1 * (10 ^ -10)) < d && d < (10 ^ 10))
+ return null;
+
+ xint = (e1.c() * e2.b() - e2.c() * e1.b())/d;
+ yint = (e2.c() * e1.a() - e1.c() * e2.a())/d;
+
+ if ((e1.reg()[1].getCoord().Y() < e2.reg()[1].getCoord().Y()) || (e1.reg()[1].getCoord().Y() == e2.reg()[1].getCoord().Y() && e1.reg()[1].getCoord().X() < e2.reg()[1].getCoord().X())) {
+ el = el1;
+ e = e1;
+ }
+ else {
+ el = el2;
+ e = e2;
+ }
+ right_of_site = (xint >= e.reg()[1].getCoord().X()) ? 1 : 0;
+ if ((right_of_site == 1 && el.elpm() == constants.le()) || right_of_site == 0 && el.elpm() == constants.re())
+ return null;
+
+ v = new Neighbor();
+ v.setRefCnt(0);
+ v.setCoord(new Point());
+ v.getCoord().setX(xint);
+ v.getCoord().setY(yint);
+ return v;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/EdgeRNG.java b/src/main/java/plugins/ragini/voronoidiagram/EdgeRNG.java
new file mode 100644
index 0000000000000000000000000000000000000000..9740600facb4f589e0a497fc4d8b331dbf9c1cd7
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/EdgeRNG.java
@@ -0,0 +1,34 @@
+package plugins.ragini.voronoidiagram;
+
+import java.awt.geom.Line2D;
+import java.util.ArrayList;
+
+public class EdgeRNG extends Line2D.Double {
+
+ private Neighbor n1, n2;
+ private ArrayList<Neighbor> endpoints;
+ private double length;
+
+ public EdgeRNG(Neighbor g1, Neighbor g2) {
+ super(g1.getCoord().X(), g1.getCoord().Y(), g2.getCoord().X(), g2.getCoord().Y());
+ n1 = g1;
+ n2 = g2;
+ endpoints = new ArrayList<Neighbor>(2);
+ endpoints.add(n1);
+ endpoints.add(n2);
+ length = distance(g1.getCoord().X(), g1.getCoord().Y(), g2.getCoord().X(), g2.getCoord().Y());
+ }
+
+ public ArrayList<Neighbor> endpoints() {
+ return endpoints;
+ }
+
+ private double distance(double ax, double ay, double bx, double by) {
+ return (Math.sqrt((bx - ax)*(bx - ax) + (by - ay)*(by - ay)));
+ }
+
+ public double length() {
+ return length;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/EdgeS.java b/src/main/java/plugins/ragini/voronoidiagram/EdgeS.java
new file mode 100644
index 0000000000000000000000000000000000000000..08c1749be5b05821c0ec277fb6ba56232498a482
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/EdgeS.java
@@ -0,0 +1,65 @@
+package plugins.ragini.voronoidiagram;
+
+public class EdgeS {
+
+ private float x1, y1, x2, y2;
+ private int nbr1, nbr2;
+ private float xm, ym;
+
+ public void setx1(float x) {
+ x1 = x;
+ }
+
+ public void sety1(float y) {
+ y1 = y;
+ }
+
+ public void setx2(float x) {
+ x2 = x;
+ }
+
+ public void sety2(float y) {
+ y2 = y;
+ }
+
+ public void setnbr1(int n) {
+ nbr1 = n;
+ }
+
+ public void setnbr2(int n) {
+ nbr2 = n;
+ }
+
+ public void setxm(float x) {
+ xm = x;
+ }
+
+ public void setym(float y) {
+ ym = y;
+ }
+
+ public float x1() {
+ return x1;
+ }
+
+ public float y1() {
+ return y1;
+ }
+
+ public float x2() {
+ return x2;
+ }
+
+ public float y2() {
+ return y2;
+ }
+
+ public int nbr1() {
+ return nbr1;
+ }
+
+ public int nbr2() {
+ return nbr2;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Face.java b/src/main/java/plugins/ragini/voronoidiagram/Face.java
new file mode 100644
index 0000000000000000000000000000000000000000..64b1e1a76a74e7cdd870a14f4851777cb7b53f8d
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Face.java
@@ -0,0 +1,291 @@
+package plugins.ragini.voronoidiagram;
+
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: Face.java
+
+import java.util.ArrayList;
+import java.util.Iterator;
+
+//Referenced classes of package delaunay:
+// QuadEdge, DT, Vertex
+
+public class Face
+{
+
+ public Face()
+ {
+ id_f = id;
+ id++;
+ edges = new QuadEdge[3];
+ S = DT.vertex_infty;
+ B = DT.vertex_infty;
+ setVal(0.0F);
+ setInvRadius(0.0D);
+ setInvSize(0.0D);
+ setMeasure(0.0D);
+ counter = 0;
+ }
+
+ public Face(QuadEdge a, QuadEdge b, QuadEdge c)
+ {
+ this();
+ setEdges(a, b, c);
+ setCenter();
+ setBary();
+ setInvSize(Math.max(Math.max(Vertex.distance(B, a.orig()), Vertex.distance(B, b.orig())), Vertex.distance(B, c.orig())));
+ setInvRadius(Vertex.distance(S, a.orig()));
+ if(DT.type == 1)
+ setMeasure(getInvRadius());
+ else
+ setMeasure(getInvSize());
+ }
+
+ public Iterator extractFacesVoisines()
+ {
+ ArrayList f_liste = new ArrayList();
+ for(int i = 0; i < 3; i++)
+ {
+ QuadEdge e = edges[i];
+ QuadEdge ee = e;
+ int count = 0;
+ do
+ {
+ count++;
+ ee = ee.onext();
+ Face fff = ee.rightFace();
+ if(fff == null)
+ fff = DT.face_null;
+ if(!f_liste.contains(fff))
+ f_liste.add(fff);
+ } while(ee != e && count < 30);
+ }
+
+ return (Iterator)f_liste.listIterator();
+ }
+
+ public Iterator extractFacesVoisines2()
+ {
+ ArrayList f_liste = new ArrayList();
+ for(int i = 0; i < 3; i++)
+ {
+ QuadEdge e = edges[i];
+ Face fff = e.sym().rightFace();
+ if(fff == null)
+ fff = DT.face_null;
+ if(!f_liste.contains(fff))
+ f_liste.add(fff);
+ }
+
+ return (Iterator)f_liste.listIterator();
+ }
+
+ public Iterator extractFacesVoisines(double angle, double epsilon)
+ {
+ if(angle < 0.0D)
+ return extractFacesVoisines();
+ ArrayList f_liste = new ArrayList();
+ for(int i = 0; i < 3; i++)
+ {
+ QuadEdge e = edges[i];
+ QuadEdge ee = e;
+ int count = 0;
+ do
+ {
+ count++;
+ Face fff = ee.rightFace();
+ if(fff == null)
+ fff = DT.face_null;
+ if(!f_liste.contains(fff))
+ if(fff != DT.face_null)
+ {
+ if(ecartAngle(fff) < epsilon)
+ f_liste.add(fff);
+ } else
+ {
+ f_liste.add(fff);
+ }
+ ee = ee.onext();
+ } while(ee != e && count < 30);
+ }
+
+ return (Iterator)f_liste.listIterator();
+ }
+
+ public Iterator extractFacesVoisines2(double angle, double epsilon)
+ {
+ if(angle < 0.0D)
+ return extractFacesVoisines2();
+ ArrayList f_liste = new ArrayList();
+ for(int i = 0; i < 3; i++)
+ {
+ QuadEdge e = edges[i];
+ Face fff = e.sym().rightFace();
+ if(fff == null)
+ fff = DT.face_null;
+ if(!f_liste.contains(fff))
+ if(fff != DT.face_null)
+ {
+ if(ecartAngle(fff) < epsilon)
+ f_liste.add(fff);
+ } else
+ {
+ f_liste.add(fff);
+ }
+ }
+
+ return (Iterator)f_liste.listIterator();
+ }
+
+ public void setCenter()
+ {
+ S = Vertex.findCenter(edges[0].orig(), edges[1].orig(), edges[2].orig());
+ }
+
+ public void setBary()
+ {
+ B = Vertex.findBary(edges[0].orig(), edges[1].orig(), edges[2].orig());
+ }
+
+ public Vertex getCenter()
+ {
+ return S;
+ }
+
+ public Vertex getBary()
+ {
+ return B;
+ }
+
+ public float getVal()
+ {
+ return val;
+ }
+
+ public float getValAux()
+ {
+ return val_aux;
+ }
+
+ public void setValAux(float val)
+ {
+ val_aux = val;
+ }
+
+ public void setVal(float val)
+ {
+ this.val = val;
+ }
+
+ public QuadEdge[] getEdges()
+ {
+ return edges;
+ }
+
+ public void setEdges(QuadEdge a, QuadEdge b, QuadEdge c)
+ {
+ edges[0] = a;
+ edges[1] = b;
+ edges[2] = c;
+ }
+
+ public void setInvRadius(double radius)
+ {
+ if(radius == 0.0D)
+ invRadius = DT.MAX_VALUE;
+ else
+ invRadius = 1.0D / radius;
+ }
+
+ public void setInvSize(double size)
+ {
+ if(size == 0.0D)
+ invSize = DT.MAX_VALUE;
+ invSize = 1.0D / size;
+ }
+
+ public void setMeasure(double measure)
+ {
+ this.measure = measure;
+ }
+
+ public double getInvRadius()
+ {
+ return invRadius;
+ }
+
+ public double getInvSize()
+ {
+ return invSize;
+ }
+
+ public double getMeasure()
+ {
+ return measure;
+ }
+
+ public int contains(Vertex p)
+ {
+ if(invSize == 0.0D)
+ return 0;
+ double size = 1.0D / (double)(float)invSize;
+ return Vertex.distance(p, B) >= size / 3D ? 0 : 1;
+ }
+
+ public void setCounter(int counter)
+ {
+ this.counter = counter;
+ }
+
+ public int getCounter()
+ {
+ return counter;
+ }
+
+ public double ecartAngle(Face f)
+ {
+ double angle2 = 0.0D;
+ Vertex angle = new Vertex(0.0D, 0.0D);
+ if(DT.vertexAngle.x == -1D && DT.vertexAngle.y == -1D)
+ return 0.0D;
+ angle.x = getCenter().x - f.getCenter().x;
+ angle.y = getCenter().y - f.getCenter().y;
+ double norme = Vertex.distance(getCenter(), f.getCenter());
+ if(norme == 0.0D)
+ {
+ return 0.0D;
+ } else
+ {
+ double cosangle = angle.x * DT.vertexAngle.x + angle.y * DT.vertexAngle.y;
+ cosangle /= norme;
+ angle2 = Math.acos(cosangle);
+ return angle2;
+ }
+ }
+
+ public String toString()
+ {
+ if(edges[0] != null)
+ return (new StringBuilder()).append(edges[0].orig()).append(" ").append(edges[1].orig()).append(" ").append(edges[2].orig()).toString();
+ else
+ return null;
+ }
+
+ private QuadEdge edges[];
+ private int counter;
+ private double invRadius;
+ private double invSize;
+ private double measure;
+ private ArrayList e;
+ private ArrayList d;
+ private Vertex S;
+ private Vertex B;
+ float val;
+ float val_aux;
+ float val_aux_angle;
+ public int id_f;
+ static int id = 0;
+
+}
+
diff --git a/src/main/java/plugins/ragini/voronoidiagram/FreeList.java b/src/main/java/plugins/ragini/voronoidiagram/FreeList.java
new file mode 100644
index 0000000000000000000000000000000000000000..2b292a185c18ed51ae7f93c5caf52398176ca26d
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/FreeList.java
@@ -0,0 +1,8 @@
+package plugins.ragini.voronoidiagram;
+
+public class FreeList {
+
+ private FreeNode head;
+ private int nodesize;
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/FreeNode.java b/src/main/java/plugins/ragini/voronoidiagram/FreeNode.java
new file mode 100644
index 0000000000000000000000000000000000000000..ccb74e3b025bb3515fb08192c891de8645d4596e
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/FreeNode.java
@@ -0,0 +1,7 @@
+package plugins.ragini.voronoidiagram;
+
+public class FreeNode {
+
+ private FreeNode nextFree;
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Geometry.java b/src/main/java/plugins/ragini/voronoidiagram/Geometry.java
new file mode 100644
index 0000000000000000000000000000000000000000..3c310080c799cdcda410134e04fe118a9201afd2
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Geometry.java
@@ -0,0 +1,98 @@
+package plugins.ragini.voronoidiagram;
+
+public class Geometry {
+
+ private int PQcount, PQmin;
+ private HalfEdge[] PQhash;
+ private Constants constants;
+
+ public Geometry(Constants _constants) {
+ constants = _constants;
+ }
+
+ public void PQinsert(HalfEdge he, Site v, double d) {
+
+
+
+ HalfEdge last, next;
+
+ he.setVertex(v);
+ he.setystar((float) (v.getCoord().Y() + d));
+ last = PQhash[PQbucket(he)];
+ while((next = last.PQnext()) != null && (he.ystar()>next.ystar() || (he.ystar() == next.ystar() && v.getCoord().X() > next.vertex().getCoord().X()))) {
+ last = next;
+ }
+ he.setPQnext(last.PQnext());
+ last.setPQnext(he);
+ PQcount +=1;
+ //System.out.println("inserting halfedge: " + he.vertex().getCoord().X() + ", " + he.ystar());
+ }
+
+ public void PQdelete(HalfEdge he) {
+ HalfEdge last;
+ if (he.vertex() != null && he.vertex().getCoord() != null)
+ //System.out.println("removing halfedge: " + he.vertex().getCoord().X() + ", " + he.ystar());
+ if (he.vertex() != null) {
+ last = PQhash[PQbucket(he)];
+ while (last.PQnext() != he) {
+ last = last.PQnext();
+ }
+ last.setPQnext(he.PQnext());
+ PQcount -=1;
+ he.setVertex(null);
+ }
+ }
+
+ public int PQbucket(HalfEdge he) {
+ int bucket;
+
+ bucket = (int) ((he.ystar() - constants.vymin())/constants.vdeltay() * constants.PQhashsize()); ///////////will this cast work?
+ if (bucket < 0) bucket = 0;
+ if (bucket >= constants.PQhashsize()) {
+ bucket = constants.PQhashsize() - 1;
+ }
+ if (bucket < PQmin) {
+ PQmin = bucket;
+ }
+ return bucket;
+ }
+
+ public boolean PQempty() {
+ return (PQcount == 0);
+ }
+
+ public Point PQmin() {
+ Point answer = new Point();
+
+ while(PQhash[PQmin].PQnext() == null) {
+ PQmin++;
+ }
+ answer.setX(PQhash[PQmin].PQnext().vertex().getCoord().X());
+ answer.setY(PQhash[PQmin].PQnext().ystar());
+ return answer;
+ }
+
+ public HalfEdge PQextractmin() {
+ HalfEdge curr;
+
+ curr = PQhash[PQmin].PQnext();
+ PQhash[PQmin].setPQnext(curr.PQnext());
+ PQcount--;
+ return curr;
+ }
+
+ public void PQinitialize() {
+ int i;
+ Point s;
+
+ PQcount = 0;
+ PQmin = 0;
+ constants.setPQhashsize((int) (4 * constants.sqrtnsites()));
+ PQhash = new HalfEdge[constants.PQhashsize()];
+ for (i = 0; i < constants.PQhashsize(); i ++) {
+ PQhash[i] = new HalfEdge(-1);
+ PQhash[i].setPQnext(null);
+ }
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/GraphD.java b/src/main/java/plugins/ragini/voronoidiagram/GraphD.java
new file mode 100644
index 0000000000000000000000000000000000000000..ebd2872b135ba81ff9a5b6d77094dcab47762d44
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/GraphD.java
@@ -0,0 +1,29 @@
+package plugins.ragini.voronoidiagram;
+
+public class GraphD {
+
+ private Point pt;
+ private Arcs arcs;
+ private short nbarcs;
+
+ public void setArcs(Arcs a) {
+ arcs = a;
+ }
+
+ public void setNbArcs(short s) {
+ nbarcs = s;
+ }
+
+ public Point pt() {
+ return pt;
+ }
+
+ public Arcs arcs() {
+ return arcs;
+ }
+
+ public short nbarcs() {
+ return nbarcs;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/HalfEdge.java b/src/main/java/plugins/ragini/voronoidiagram/HalfEdge.java
new file mode 100644
index 0000000000000000000000000000000000000000..212fc6844df112dc4ab94ad050b9dcf258b7cd2e
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/HalfEdge.java
@@ -0,0 +1,103 @@
+package plugins.ragini.voronoidiagram;
+
+public class HalfEdge {
+
+ private HalfEdge ELleft, ELRight;
+ private Edge ELedge;
+ private int ELrefcnt;
+ private int ELpm;
+ private Site vertex;
+ private float ystar;
+ private HalfEdge PQNext;
+ private boolean isnull;
+ private boolean isdeleted;
+ private int origin;
+
+ public HalfEdge(int i) {
+ isnull = true;
+ isdeleted = false;
+ ELpm = -1;
+ origin = i;
+ }
+
+ public Site vertex() {
+ return vertex;
+ }
+
+ public Edge eledge() {
+ return ELedge;
+ }
+
+ public int elpm() {
+ return ELpm;
+ }
+
+ public void setLeft(HalfEdge l) {
+ ELleft = l;
+ }
+
+ public void setRight(HalfEdge r) {
+ ELRight = r;
+ }
+
+ public void setEdge(Edge e) {
+ ELedge = e;
+ }
+
+ public void setPM(int p) {
+ ELpm = p;
+ }
+
+ public void setNext(HalfEdge n) {
+ PQNext = n;
+ }
+
+ public void setVertex(Site s) {
+ vertex = s;
+ }
+
+ public HalfEdge left() {
+ return ELleft;
+ }
+
+ public HalfEdge right() {
+ return ELRight;
+ }
+
+ public void setystar(float d) {
+ ystar = d;
+ }
+
+ public HalfEdge PQnext() {
+ return PQNext;
+ }
+
+ public float ystar() {
+ return ystar;
+ }
+
+ public void setPQnext(HalfEdge h) {
+ PQNext = h;
+ }
+
+ public boolean isNull() {
+ return isnull;
+ }
+
+ public boolean isDeleted() {
+ return isdeleted;
+ }
+
+ public void setNull(boolean b) {
+ isnull = b;
+ }
+
+ public void setDeleted(boolean b) {
+ isdeleted = b;
+ }
+
+ public int origin() {
+ return origin;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Image_Extract.java b/src/main/java/plugins/ragini/voronoidiagram/Image_Extract.java
new file mode 100644
index 0000000000000000000000000000000000000000..8410708729509d02b8ebb2410b651e8f23b13499
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Image_Extract.java
@@ -0,0 +1,69 @@
+package plugins.ragini.voronoidiagram;
+
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: Image_Extract.java
+
+import ij.ImagePlus;
+import ij.WindowManager;
+import ij.plugin.filter.MaximumFinder;
+import ij.plugin.filter.PlugInFilter;
+import ij.process.ByteProcessor;
+import ij.process.ImageProcessor;
+import java.awt.Rectangle;
+import javax.swing.JOptionPane;
+
+public class Image_Extract
+ implements PlugInFilter
+{
+
+ public Image_Extract()
+ {
+ }
+
+ public int setup(String arg, ImagePlus imp)
+ {
+ return 127;
+ }
+
+ public void run(ImageProcessor ip)
+ {
+ imp = WindowManager.getCurrentImage();
+ ImageProcessor ip2 = imp.getProcessor().resize(imp.getWidth(), imp.getHeight());
+ (new ImagePlus("Init", ip2)).show();
+ ip = ip.convertToByte(true);
+ double tolerance = 30D;
+ double input = -1D;
+ String s = "30";
+ s = JOptionPane.showInputDialog("Input the tolerance parameter (30 by default):", "30");
+ input = Double.valueOf(s).doubleValue();
+ if(input > 0.0D)
+ tolerance = input;
+ Rectangle r = ip.getRoi();
+ ip.invert();
+ ByteProcessor bp = (new MaximumFinder()).findMaxima(ip, tolerance, -808080D, 0, true, false);
+ ip.setPixels(bp.getPixels());
+ ip.invertLut();
+ ip = ip.convertToRGB();
+ imp.setProcessor("RGB", ip);
+ imp.repaintWindow();
+ int mask = 255;
+ for(int y = r.y; y < r.y + r.height; y++)
+ {
+ for(int x = r.x; x < r.x + r.width; x++)
+ {
+ int rgb = ip.get(x, y);
+ int rouge = rgb >> 16 & mask;
+ int vert = rgb >> 8 & mask;
+ int bleu = rgb & mask;
+ if(rouge == 0 && bleu == 0 && vert == 0)
+ ip.set(x, y, 0xff0000);
+ }
+
+ }
+
+ }
+
+ private ImagePlus imp;
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/IntArraySetter.java b/src/main/java/plugins/ragini/voronoidiagram/IntArraySetter.java
new file mode 100644
index 0000000000000000000000000000000000000000..a4ad0bc88855434096ba7dd85f41cf9943e4f04a
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/IntArraySetter.java
@@ -0,0 +1,17 @@
+package plugins.ragini.voronoidiagram;
+
+public class IntArraySetter implements Setter<Integer[][]> {
+
+ private Integer[][] var;
+
+ @Override
+ public void set(Integer[][] input) {
+ var = input;
+ }
+
+ @Override
+ public Integer[][] get() {
+ return var;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/IntSetter.java b/src/main/java/plugins/ragini/voronoidiagram/IntSetter.java
new file mode 100644
index 0000000000000000000000000000000000000000..144fba85dbc8dc2bbb374b81efcc42ca22d23b0c
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/IntSetter.java
@@ -0,0 +1,21 @@
+package plugins.ragini.voronoidiagram;
+
+public class IntSetter implements Setter<Integer> {
+
+ Integer n;
+
+ public IntSetter (int i) {
+ n = new Integer(i);
+ }
+
+ @Override
+ public void set(Integer input) {
+ n = input;
+ }
+
+ @Override
+ public Integer get() {
+ return n;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/MorphologicalOperators.java b/src/main/java/plugins/ragini/voronoidiagram/MorphologicalOperators.java
new file mode 100644
index 0000000000000000000000000000000000000000..926ba5d8187f42207568d9244b85d296c5d3b7c3
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/MorphologicalOperators.java
@@ -0,0 +1,15 @@
+package plugins.ragini.voronoidiagram;
+
+import icy.gui.dialog.MessageDialog;
+import icy.plugin.abstract_.Plugin;
+import icy.plugin.interface_.PluginImageAnalysis;
+
+public class MorphologicalOperators extends Plugin implements PluginImageAnalysis {
+
+ @Override
+ public void compute() {
+ // TODO Auto-generated by Icy4Eclipse
+ MessageDialog.showDialog("MorphologicalOperators is working fine !");
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/NVert.java b/src/main/java/plugins/ragini/voronoidiagram/NVert.java
new file mode 100644
index 0000000000000000000000000000000000000000..051af8541bd2024986b164d252c8063aaed7d87b
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/NVert.java
@@ -0,0 +1,39 @@
+package plugins.ragini.voronoidiagram;
+
+public class NVert {
+
+ private int nbr1, nbr2, onhull, vpid;
+
+ public int onhull() {
+ return onhull;
+ }
+
+ public void setOnHull(int o) {
+ onhull = o;
+ }
+
+ public int nbr1() {
+ return nbr1;
+ }
+
+ public int nbr2() {
+ return nbr2;
+ }
+
+ public void setNbr1(int n) {
+ nbr1 = n;
+ }
+
+ public void setNbr2(int n) {
+ nbr2 = n;
+ }
+
+ public void setVPid(int v) {
+ vpid = v;
+ }
+
+ public int vpid() {
+ return vpid;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Neighbor.java b/src/main/java/plugins/ragini/voronoidiagram/Neighbor.java
new file mode 100644
index 0000000000000000000000000000000000000000..3d132606e4a812330cd17f7935ec0a5d77ae4719
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Neighbor.java
@@ -0,0 +1,32 @@
+package plugins.ragini.voronoidiagram;
+
+import java.util.ArrayList;
+
+public class Neighbor extends Site implements PointType {
+
+ private double dist;
+ private Site site;
+ private ArrayList<Neighbor> samedist;
+
+ public Neighbor() {
+ super();
+ samedist = new ArrayList<Neighbor>();
+ }
+
+ public Site getSite() {
+ return site;
+ }
+
+ public void addNeighbor(Neighbor n) {
+ neighbors.add(n);
+ }
+
+ public void same(Neighbor n) {
+ samedist.add(n);
+ }
+
+ public ArrayList<Neighbor> samedistpoints() {
+ return samedist;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Point.java b/src/main/java/plugins/ragini/voronoidiagram/Point.java
new file mode 100644
index 0000000000000000000000000000000000000000..7895654ff288568b105e709c1c431a4b7d6b82ff
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Point.java
@@ -0,0 +1,23 @@
+package plugins.ragini.voronoidiagram;
+
+public class Point {
+
+ protected float x, y;
+
+ public float X(){
+ return x;
+ }
+
+ public float Y() {
+ return y;
+ }
+
+ public void setX(float _x) {
+ x = _x;
+ }
+
+ public void setY(float _y) {
+ y = _y;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/PointType.java b/src/main/java/plugins/ragini/voronoidiagram/PointType.java
new file mode 100644
index 0000000000000000000000000000000000000000..614a81cad356aff879340aa57d435715ed8904c0
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/PointType.java
@@ -0,0 +1,5 @@
+package plugins.ragini.voronoidiagram;
+
+public interface PointType {
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/PointVor.java b/src/main/java/plugins/ragini/voronoidiagram/PointVor.java
new file mode 100644
index 0000000000000000000000000000000000000000..cce2fe3096f5725ea087d59ddd0cdc3351138f76
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/PointVor.java
@@ -0,0 +1,5 @@
+package plugins.ragini.voronoidiagram;
+
+public class PointVor {
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Provider.java b/src/main/java/plugins/ragini/voronoidiagram/Provider.java
new file mode 100644
index 0000000000000000000000000000000000000000..dc34fc22e74e74239653353cfba12724bb697a7a
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Provider.java
@@ -0,0 +1,7 @@
+package plugins.ragini.voronoidiagram;
+
+public interface Provider<T> {
+
+ public T next();
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/QuadEdge.java b/src/main/java/plugins/ragini/voronoidiagram/QuadEdge.java
new file mode 100644
index 0000000000000000000000000000000000000000..177d36226baadf44f6cf52d624a60a922969a02a
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/QuadEdge.java
@@ -0,0 +1,289 @@
+package plugins.ragini.voronoidiagram;
+
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: QuadEdge.java
+
+import java.io.PrintStream;
+
+//Referenced classes of package delaunay:
+// Vertex, Face
+
+public class QuadEdge
+{
+
+ public QuadEdge(QuadEdge Onext, QuadEdge rot, Vertex data, boolean can)
+ {
+ this.Onext = Onext;
+ this.data = data;
+ this.rot = rot;
+ canonical = can;
+ counter = 0;
+ alpha = 0.0D;
+ }
+
+ public static QuadEdge makeEdge(Vertex orig, Vertex dest)
+ {
+ QuadEdge q0 = new QuadEdge(null, null, null, true);
+ QuadEdge q1 = new QuadEdge(null, null, null, false);
+ QuadEdge q2 = new QuadEdge(null, null, null, false);
+ QuadEdge q3 = new QuadEdge(null, null, null, true);
+ q0.rot = q1;
+ q1.rot = q2;
+ q2.rot = q3;
+ q3.rot = q0;
+ q0.Onext = q0;
+ q1.Onext = q3;
+ q2.Onext = q2;
+ q3.Onext = q1;
+ q0.setData(orig);
+ q0.sym().setData(dest);
+ return q0;
+ }
+
+ public static void splice(QuadEdge q1, QuadEdge q2)
+ {
+ QuadEdge alpha = q1.onext().rot();
+ QuadEdge beta = q2.onext().rot();
+ QuadEdge t1 = q2.onext();
+ QuadEdge t2 = q1.onext();
+ QuadEdge t3 = beta.onext();
+ QuadEdge t4 = alpha.onext();
+ q1.setOnext(t1);
+ q2.setOnext(t2);
+ alpha.setOnext(t3);
+ beta.setOnext(t4);
+ }
+
+ public void splice(QuadEdge q)
+ {
+ splice(this, q);
+ }
+
+ public static void splice2(QuadEdge q1, QuadEdge q2)
+ {
+ q2.rot().setOnext(q1.rotSym());
+ q1.setOnext(q2);
+ }
+
+ public void splice2(QuadEdge q)
+ {
+ splice2(this, q);
+ }
+
+ public static QuadEdge connect(QuadEdge a, QuadEdge b)
+ {
+ QuadEdge q = makeEdge(a.dest(), b.orig());
+ splice(q, a.lnext());
+ splice(q.sym(), b);
+ return q;
+ }
+
+ public static void deleteEdge(QuadEdge q)
+ {
+ splice(q, q.oprev());
+ splice(q.sym(), q.sym().oprev());
+ }
+
+ public int getCounter()
+ {
+ return counter;
+ }
+
+ public void setCounter(int c)
+ {
+ counter = c;
+ }
+
+ public void setFace(Face f)
+ {
+ rightF = f;
+ }
+
+ public void setFaces(Face f, Face g)
+ {
+ rightF = f;
+ sym().rightF = g;
+ }
+
+ public void setAlpha(double alpha)
+ {
+ this.alpha = alpha;
+ }
+
+ public double getAlpha()
+ {
+ return alpha;
+ }
+
+ public void setLambda(float lbd)
+ {
+ lambda_val = lbd;
+ }
+
+ public float getLambda()
+ {
+ return lambda_val;
+ }
+
+ public void setMu(float lbd)
+ {
+ mu_val = lbd;
+ }
+
+ public float getMu()
+ {
+ return mu_val;
+ }
+
+ public void setOnext(QuadEdge next)
+ {
+ Onext = next;
+ }
+
+ public void setRot(QuadEdge rot)
+ {
+ this.rot = rot;
+ }
+
+ public void setData(Vertex data)
+ {
+ this.data = data;
+ }
+
+ public QuadEdge onext()
+ {
+ return Onext;
+ }
+
+ public QuadEdge rot()
+ {
+ return rot;
+ }
+
+ public QuadEdge sym()
+ {
+ return rot.rot();
+ }
+
+ public Vertex orig()
+ {
+ return data;
+ }
+
+ public Vertex dest()
+ {
+ return sym().orig();
+ }
+
+ public Vertex right()
+ {
+ return rot.orig();
+ }
+
+ public Vertex left()
+ {
+ return rot.sym().orig();
+ }
+
+ public Face rightFace()
+ {
+ return rightF;
+ }
+
+ public QuadEdge rotSym()
+ {
+ return rot.sym();
+ }
+
+ public QuadEdge oprev()
+ {
+ return rot.onext().rot();
+ }
+
+ public QuadEdge lnext()
+ {
+ return rotSym().onext().rot();
+ }
+
+ public QuadEdge lprev()
+ {
+ return onext().sym();
+ }
+
+ public QuadEdge rnext()
+ {
+ return rot.onext().rotSym();
+ }
+
+ public QuadEdge rprev()
+ {
+ return sym().onext();
+ }
+
+ public boolean isCanonical()
+ {
+ return canonical;
+ }
+
+ public boolean rightOf(Vertex s)
+ {
+ return s.ccw(sym().data, data);
+ }
+
+ public static boolean rightOf(QuadEdge q, Vertex s)
+ {
+ return s.ccw(q.dest(), q.orig());
+ }
+
+ public boolean leftOf(Vertex s)
+ {
+ return s.ccw(data, dest());
+ }
+
+ public static boolean leftOf(Vertex s, QuadEdge q)
+ {
+ return s.ccw(q.orig(), q.dest());
+ }
+
+ boolean equals(QuadEdge e)
+ {
+ return orig() == e.orig() && dest() == e.dest();
+ }
+
+ boolean equivalent(QuadEdge e)
+ {
+ return orig() == e.orig() && dest() == e.dest() || orig() == e.dest() && dest() == e.orig();
+ }
+
+ public int type(double med, int axis)
+ {
+ if(!orig().test(med, axis))
+ return dest().test(med, axis) ? 0 : -1;
+ return !dest().test(med, axis) ? 0 : 1;
+ }
+
+ public String toString()
+ {
+ return (new StringBuilder()).append(data).append(" ").append(sym().data).toString();
+ }
+
+ public void expliciter()
+ {
+ QuadEdge sym = sym();
+ System.out.println((new StringBuilder(" Edge")).append(this).append(" onext()").append(onext()).append(" oprev").append(oprev()).append(" lnext").append(lnext()).append(" rprev").append(rprev()).toString());
+ System.out.println((new StringBuilder(" Edge inverse ")).append(sym).append(" onext()").append(sym.onext()).append(" oprev").append(sym.oprev()).append(" lnext").append(sym.lnext()).append(" rprev").append(sym.rprev()).toString());
+ }
+
+ private QuadEdge Onext;
+ private QuadEdge rot;
+ private Vertex data;
+ private int counter;
+ private Face rightF;
+ private double alpha;
+ private float lambda_val;
+ private float mu_val;
+ private boolean canonical;
+}
+
diff --git a/src/main/java/plugins/ragini/voronoidiagram/ROI2DEdge.java b/src/main/java/plugins/ragini/voronoidiagram/ROI2DEdge.java
new file mode 100644
index 0000000000000000000000000000000000000000..5e4b0bc9840a1a61988f1ef7161881aa2987773b
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/ROI2DEdge.java
@@ -0,0 +1,13 @@
+package plugins.ragini.voronoidiagram;
+
+import icy.roi.ROI2DLine;
+
+import java.awt.geom.Line2D;
+
+public class ROI2DEdge extends ROI2DLine {
+
+ public ROI2DEdge(Line2D line) {
+ super(line.getP1(), line.getP2());
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/ROI2DSite.java b/src/main/java/plugins/ragini/voronoidiagram/ROI2DSite.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0493675e86f30f08fdceb00a792eb50794d8f13
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/ROI2DSite.java
@@ -0,0 +1,22 @@
+package plugins.ragini.voronoidiagram;
+import java.awt.geom.Point2D;
+
+import icy.roi.ROI2DPoint;
+
+public class ROI2DSite extends ROI2DPoint {
+
+ private Site site;
+
+ public ROI2DSite(Point2D dp) {
+ super(dp);
+ }
+
+ public void setSite(Site s) {
+ site = s;
+ }
+
+ public Site getSite() {
+ return site;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Setter.java b/src/main/java/plugins/ragini/voronoidiagram/Setter.java
new file mode 100644
index 0000000000000000000000000000000000000000..b2aa0579290c498ed9fd53920903c56484d7b47c
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Setter.java
@@ -0,0 +1,9 @@
+package plugins.ragini.voronoidiagram;
+
+public interface Setter<T> {
+
+ public void set(T input);
+
+ public T get();
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Site.java b/src/main/java/plugins/ragini/voronoidiagram/Site.java
new file mode 100644
index 0000000000000000000000000000000000000000..63d5eb56b23e45cee772f8f49bc06eb87f11e874
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Site.java
@@ -0,0 +1,87 @@
+package plugins.ragini.voronoidiagram;
+
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class Site {
+
+ protected PriorityQueue<Neighbor> neighbors;
+ protected Point coord;
+ private int sitenbr, refcnt;
+ private ROI2DSite point;
+
+ public Site() {
+ NeighborComp comp = new NeighborComp();
+ neighbors = new PriorityQueue<Neighbor>(5, comp);
+ }
+
+ public Point getCoord() {
+ return coord;
+ }
+
+ public int sitenbr() {
+ return sitenbr;
+ }
+
+ public void setRefCnt(int r) {
+ refcnt = r;
+ }
+
+ public void setSiteNbr(int n) {
+ sitenbr = n;
+ }
+///>>>????
+
+ public void setCoord(Point p) {
+ coord = p;
+ }
+
+ public PriorityQueue<Neighbor> neighbors() {
+ return neighbors;
+ }
+
+ private class NeighborComp implements Comparator<Neighbor> {
+
+ @Override
+ public int compare(Neighbor n1, Neighbor n2) {
+ if (distance(coord.X(), coord.Y(), n1.getCoord().X(), n1.getCoord().Y()) > distance(coord.X(), coord.Y(), n2.getCoord().X(), n2.getCoord().Y()))
+ return 1;
+ else if (distance(coord.X(), coord.Y(), n1.getCoord().X(), n1.getCoord().Y()) < distance(coord.X(), coord.Y(), n2.getCoord().X(), n2.getCoord().Y()))
+ return -1;
+ else if (n1.getCoord().Y() > n2.getCoord().Y()) {
+ n2.same(n1);
+ n1.same(n2);
+ return 1; }
+ else if (n1.getCoord().Y() < n2.getCoord().Y()) {
+ n1.same(n2);
+ n2.same(n1);
+ return -1; }
+ else if (n1.getCoord().X() > n2.getCoord().X()) {
+ n2.same(n1);
+ n1.same(n2);
+ return 1; }
+ else if (n1.getCoord().X() < n2.getCoord().X()) {
+ n1.same(n2);
+ n2.same(n1);
+ return -1; }
+ else {
+ System.out.println("here");
+ return 0;
+ }
+ }
+
+ private double distance(double ax, double ay, double bx, double by) {
+ return (Math.sqrt((bx - ax)*(bx - ax) + (by - ay)*(by - ay)));
+ }
+
+ }
+
+ public void setPoint(ROI2DSite p) {
+ point = p;
+ }
+
+ public ROI2DSite getPoint() {
+ return point;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/SiteProvider.java b/src/main/java/plugins/ragini/voronoidiagram/SiteProvider.java
new file mode 100644
index 0000000000000000000000000000000000000000..c86a081b5c06e95296f22ba5e6512d013dabdf91
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/SiteProvider.java
@@ -0,0 +1,26 @@
+package plugins.ragini.voronoidiagram;
+
+public class SiteProvider implements Provider<Neighbor> {
+
+ private int index;
+ private int lim;
+ private Constants cons;
+
+ public SiteProvider (Constants _cons) {
+ index = 0;
+ cons = _cons;
+ lim = cons.sites().length;
+ }
+
+ @Override
+ public Neighbor next() {
+ Neighbor out = null;
+ if (index < lim) {
+ out = cons.sites()[index];
+ index++;
+ }
+ //System.out.println("newsite: " + out.getCoord().X() + " " + out.getCoord().Y());
+ return out;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Tri.java b/src/main/java/plugins/ragini/voronoidiagram/Tri.java
new file mode 100644
index 0000000000000000000000000000000000000000..f05a0789641496b4313e6804a68acc74711b98a2
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Tri.java
@@ -0,0 +1,31 @@
+package plugins.ragini.voronoidiagram;
+
+public class Tri {
+
+ private Vert v1, v2, v3;
+
+ public void setV1(Vert v) {
+ v1 = v;
+ }
+
+ public void setV2(Vert v) {
+ v2 = v;
+ }
+
+ public void setV3(Vert v) {
+ v3 = v;
+ }
+
+ public Vert v1() {
+ return v1;
+ }
+
+ public Vert v2() {
+ return v2;
+ }
+
+ public Vert v3() {
+ return v3;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/UniformGrid.java b/src/main/java/plugins/ragini/voronoidiagram/UniformGrid.java
new file mode 100644
index 0000000000000000000000000000000000000000..18959cab7522c14aecc67674342de2fe734f1ec1
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/UniformGrid.java
@@ -0,0 +1,719 @@
+package plugins.ragini.voronoidiagram;
+
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: UniformGrid.java
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+//Referenced classes of package delaunay:
+// Vertex, DT, QuadEdge
+
+public class UniformGrid
+{
+ class GridCell
+ {
+
+ PointItem points;
+ int mark;
+ final UniformGrid this$0;
+
+ GridCell()
+ {
+ super();
+ this$0 = UniformGrid.this;
+ points = null;
+ mark = -1;
+ }
+ }
+
+ class GridInterval
+ {
+
+ void set()
+ {
+ x1 = y1 = 0;
+ x2 = xsize;
+ y2 = ysize;
+ }
+
+ void set(int X1, int Y1, int X2, int Y2)
+ {
+ x1 = X1 < 0 ? 0 : X1;
+ y1 = Y1 < 0 ? 0 : Y1;
+ x2 = X2 > xsize ? xsize : X2;
+ y2 = Y2 > ysize ? ysize : Y2;
+ }
+
+ void set(Vertex v, double radius)
+ {
+ int X1 = (int)((v.x - radius - xoffset) / cellsize);
+ int Y1 = (int)((v.y - radius - yoffset) / cellsize);
+ int X2 = (int)(((v.x + radius) - xoffset) / cellsize) + 1;
+ int Y2 = (int)(((v.y + radius) - yoffset) / cellsize) + 1;
+ set(X1, Y1, X2, Y2);
+ }
+
+ public String toString()
+ {
+ if(x1 < x2 && y1 < y2)
+ return (new StringBuilder("[")).append(x1).append("..").append(x2 - 1).append("][").append(y1).append("..").append(y2 - 1).append("]").toString();
+ else
+ return "[empty]";
+ }
+
+ int x1;
+ int y1;
+ int x2;
+ int y2;
+ final UniformGrid this$0;
+
+ GridInterval(int X1, int Y1, int X2, int Y2)
+ {
+ super();
+ this$0 = UniformGrid.this;
+ set(X1, Y1, X2, Y2);
+ }
+
+ GridInterval(Vertex v, double radius)
+ {
+ super();
+ this$0 = UniformGrid.this;
+ set(v, radius);
+ }
+ }
+
+ class GridPosition
+ {
+
+ int x;
+ int y;
+ final UniformGrid this$0;
+
+ GridPosition(Vertex v)
+ {
+ super();
+ this$0 = UniformGrid.this;
+ x = (int)((v.x - xoffset) / cellsize);
+ y = (int)((v.y - yoffset) / cellsize);
+ if(x < 0)
+ x = 0;
+ if(x >= xsize)
+ x = xsize - 1;
+ if(y < 0)
+ y = 0;
+ if(y >= ysize)
+ y = ysize - 1;
+ }
+ }
+
+ class PointItem
+ {
+
+ Vertex point;
+ PointItem next;
+ final UniformGrid this$0;
+
+ PointItem()
+ {
+ super();
+ this$0 = UniformGrid.this;
+ point = null;
+ next = null;
+ }
+ }
+
+ class PointIterator
+ implements Iterator
+ {
+
+ public boolean hasNext()
+ {
+ return ptr != null;
+ }
+
+ public Object next()
+ {
+ if(ptr == null)
+ {
+ throw new NoSuchElementException();
+ } else
+ {
+ Vertex res = ptr.point;
+ ptr = ptr.next;
+ return res;
+ }
+ }
+
+ public void remove()
+ {
+ throw new UnsupportedOperationException();
+ }
+
+ PointItem ptr;
+ final UniformGrid this$0;
+
+ PointIterator(int x, int y)
+ {
+ super();
+ this$0 = UniformGrid.this;
+ ptr = null;
+ ptr = grid[x][y].points;
+ }
+ }
+
+
+ UniformGrid(Vertex verts[], int mincells)
+ {
+ grid = null;
+ array = null;
+ xsize = 0;
+ ysize = 0;
+ xoffset = 0.0D;
+ yoffset = 0.0D;
+ cellsize = 0.0D;
+ currentMark = 0;
+ array = new PointItem[verts.length];
+ for(int i = 0; i < array.length; i++)
+ array[i] = new PointItem();
+
+ double xmax;
+ double xmin = xmax = verts[0].x;
+ double ymax;
+ double ymin = ymax = verts[0].y;
+ for(int i = 1; i < verts.length; i++)
+ {
+ if(verts[i].x < xmin)
+ xmin = verts[i].x;
+ if(verts[i].x > xmax)
+ xmax = verts[i].x;
+ if(verts[i].y < ymin)
+ ymin = verts[i].y;
+ if(verts[i].y > ymax)
+ ymax = verts[i].y;
+ }
+
+ cellsize = Math.sqrt(((xmax - xmin) * (ymax - ymin)) / (double)mincells);
+ xsize = (int)Math.ceil((xmax - xmin) / cellsize);
+ ysize = (int)Math.ceil((ymax - ymin) / cellsize);
+ xoffset = xmin - (cellsize * (double)xsize - (xmax - xmin)) / 2D;
+ yoffset = ymin - (cellsize * (double)ysize - (ymax - ymin)) / 2D;
+ grid = new GridCell[xsize][ysize];
+ for(int i = 0; i < xsize; i++)
+ {
+ for(int j = 0; j < ysize; j++)
+ grid[i][j] = new GridCell();
+
+ }
+
+ for(int i = 0; i < verts.length; i++)
+ {
+ int x = (int)((verts[i].x - xoffset) / cellsize);
+ int y = (int)((verts[i].y - yoffset) / cellsize);
+ if(x < 0)
+ x = 0;
+ if(x >= xsize)
+ x = xsize - 1;
+ if(y < 0)
+ y = 0;
+ if(y >= ysize)
+ y = ysize - 1;
+ array[i].point = verts[i];
+ array[i].next = null;
+ if(grid[x][y].points == null)
+ {
+ grid[x][y].points = array[i];
+ } else
+ {
+ PointItem last;
+ for(last = grid[x][y].points; last.next != null; last = last.next);
+ last.next = array[i];
+ }
+ }
+
+ }
+
+ public int XCells()
+ {
+ return xsize;
+ }
+
+ public int YCells()
+ {
+ return ysize;
+ }
+
+ public double XMin()
+ {
+ return xoffset;
+ }
+
+ public double YMin()
+ {
+ return yoffset;
+ }
+
+ public double XMax()
+ {
+ return xoffset + (double)xsize * cellsize;
+ }
+
+ public double YMax()
+ {
+ return yoffset + (double)ysize * cellsize;
+ }
+
+ public double XSize()
+ {
+ return (double)xsize * cellsize;
+ }
+
+ public double YSize()
+ {
+ return (double)ysize * cellsize;
+ }
+
+ public double CellSize()
+ {
+ return cellsize;
+ }
+
+ public PointIterator cellIterator(int x, int y)
+ {
+ return new PointIterator(x, y);
+ }
+
+ void resetAllMarks()
+ {
+ currentMark++;
+ }
+
+ void setMark(int x, int y)
+ {
+ grid[x][y].mark = currentMark;
+ }
+
+ void unsetMark(int x, int y)
+ {
+ grid[x][y].mark = currentMark - 1;
+ }
+
+ boolean isMarked(int x, int y)
+ {
+ return grid[x][y].mark == currentMark;
+ }
+
+ public int numPoints(int x1, int y1, int x2, int y2)
+ {
+ int cnt = 0;
+ for(int i = x1; i < x2; i++)
+ {
+ for(int j = y1; j < y2; j++)
+ {
+ for(PointIterator pi = cellIterator(i, j); pi.hasNext();)
+ {
+ pi.next();
+ cnt++;
+ }
+
+ }
+
+ }
+
+ return cnt;
+ }
+
+ public double pseudoMedian(int axis)
+ {
+ int cfirst = 0;
+ int clast = 0;
+ int cnt = 0;
+ double med = 0.0D;
+ switch(axis)
+ {
+ default:
+ break;
+
+ case 0: // '\0'
+ {
+ int pfirst = 0;
+ for(int plast = xsize - 1; pfirst < plast;)
+ if(cfirst <= clast)
+ {
+ cfirst += numPoints(pfirst, 0, pfirst + 1, ysize);
+ pfirst++;
+ } else
+ {
+ clast += numPoints(plast, 0, plast + 1, ysize);
+ plast--;
+ }
+
+ for(int i = 0; i < ysize; i++)
+ {
+ for(PointIterator pi = cellIterator(pfirst, i); pi.hasNext();)
+ {
+ med += ((Vertex)pi.next()).x;
+ cnt++;
+ }
+
+ }
+
+ if(cnt > 0)
+ med /= cnt;
+ else
+ med = (double)pfirst * cellsize + xoffset;
+ break;
+ }
+
+ case 1: // '\001'
+ {
+ int pfirst = 0;
+ for(int plast = ysize - 1; pfirst < plast;)
+ if(cfirst <= clast)
+ {
+ cfirst += numPoints(0, pfirst, xsize, pfirst + 1);
+ pfirst++;
+ } else
+ {
+ clast += numPoints(0, plast, xsize, plast + 1);
+ plast--;
+ }
+
+ for(int i = 0; i < xsize; i++)
+ {
+ for(PointIterator pi = cellIterator(i, pfirst); pi.hasNext();)
+ {
+ med += ((Vertex)pi.next()).y;
+ cnt++;
+ }
+
+ }
+
+ if(cnt > 0)
+ med /= cnt;
+ else
+ med = (double)pfirst * cellsize + yoffset;
+ break;
+ }
+ }
+ return med;
+ }
+
+ public Vertex findNearestPointLinear(Vertex v)
+ {
+ double dist = 0.0D;
+ Vertex found = null;
+ for(int i = 0; i < array.length; i++)
+ if(array[i].point != v)
+ {
+ double pom = Vertex.sqrDistance(v, array[i].point);
+ if(found == null || pom < dist)
+ {
+ found = array[i].point;
+ dist = pom;
+ }
+ }
+
+ return found;
+ }
+
+ public Vertex findDelaunayPointLinear(Vertex a, Vertex b)
+ {
+ double dist = 0.0D;
+ Vertex found = null;
+ for(int i = 0; i < array.length; i++)
+ if(array[i].point != a && array[i].point != b && Vertex.ccw(a, b, array[i].point))
+ {
+ double pom = Vertex.delaunayDistance(a, b, array[i].point);
+ if(found == null || pom < dist)
+ {
+ found = array[i].point;
+ dist = pom;
+ }
+ }
+
+ return found;
+ }
+
+ public Vertex findFirst(Vertex v)
+ {
+ resetAllMarks();
+ Vertex found = null;
+ GridPosition gp = new GridPosition(v);
+ GridInterval gr = new GridInterval(gp.x, gp.y, gp.x + 1, gp.y + 1);
+label0:
+ while(found == null)
+ {
+ for(int i = gr.x1; i < gr.x2; i++)
+ {
+ for(int j = gr.y1; j < gr.y2; j++)
+ {
+ if(isMarked(i, j))
+ continue;
+ for(PointIterator pi = cellIterator(i, j); pi.hasNext();)
+ {
+ Vertex pom = (Vertex)pi.next();
+ if(pom != v)
+ {
+ found = pom;
+ break label0;
+ }
+ }
+
+ setMark(i, j);
+ }
+
+ }
+
+ if(gr.x1 == 0 && gr.y1 == 0 && gr.x2 == xsize && gr.y2 == ysize)
+ break;
+ gr.set(gr.x1 - 1, gr.y1 - 1, gr.x2 + 1, gr.y2 + 1);
+ }
+ return found;
+ }
+
+ public Vertex findNearestPoint(Vertex v)
+ {
+ Vertex found = findFirst(v);
+ if(found == null)
+ return null;
+ double dist = Vertex.distance(v, found);
+ GridInterval gr = new GridInterval(v, dist);
+ for(int i = gr.x1; i < gr.x2; i++)
+ {
+ for(int j = gr.y1; j < gr.y2; j++)
+ if(!isMarked(i, j))
+ {
+ for(PointIterator pi = cellIterator(i, j); pi.hasNext();)
+ {
+ Vertex pom = (Vertex)pi.next();
+ if(pom != v)
+ {
+ double dd = Vertex.distance(pom, v);
+ if(dd < dist)
+ {
+ dist = dd;
+ found = pom;
+ gr.set(v, dist);
+ }
+ }
+ }
+
+ setMark(i, j);
+ }
+
+ }
+
+ return found;
+ }
+
+ public Vertex findDelaunayPoint(Vertex a, Vertex b)
+ {
+ resetAllMarks();
+ Vertex found = null;
+ GridPosition gp = new GridPosition(new Vertex((a.x + b.x) / 2D, (a.y + b.y) / 2D));
+ GridInterval gr = new GridInterval(gp.x, gp.y, gp.x + 1, gp.y + 1);
+ Vertex S;
+label0:
+ while(found == null)
+ {
+ for(int i = gr.x1; i < gr.x2; i++)
+ {
+ for(int j = gr.y1; j < gr.y2; j++)
+ {
+ if(isMarked(i, j))
+ continue;
+ for(PointIterator pi = cellIterator(i, j); pi.hasNext();)
+ {
+ Vertex pom = (Vertex)pi.next();
+ S = Vertex.findCenter(a, b, pom);
+ double rad = Vertex.distance(S, a);
+ if(pom != a && pom != b && Vertex.ccw(a, b, pom) && rad < DT.MAX_VALUE)
+ {
+ found = pom;
+ break label0;
+ }
+ }
+
+ setMark(i, j);
+ }
+
+ }
+
+ if(gr.x1 == 0 && gr.y1 == 0 && gr.x2 == xsize && gr.y2 == ysize)
+ break;
+ gr.set(gr.x1 - 1, gr.y1 - 1, gr.x2 + 1, gr.y2 + 1);
+ }
+ if(found == null)
+ return null;
+ S = Vertex.findCenter(a, b, found);
+ double dist = Vertex.distance(S, a);
+ if(!Vertex.ccw(a, b, S))
+ dist = -dist;
+ gr.set(S, Math.abs(dist));
+ for(int i = gr.x1; i < gr.x2; i++)
+ {
+label1:
+ for(int j = gr.y1; j < gr.y2; j++)
+ {
+ if(isMarked(i, j))
+ continue;
+ for(PointIterator pi = cellIterator(i, j); pi.hasNext();)
+ {
+ Vertex pom = (Vertex)pi.next();
+ if(pom != a && pom != b && Vertex.ccw(a, b, pom))
+ {
+ S = Vertex.findCenter(a, b, pom);
+ double dd = Vertex.distance(S, a);
+ if(!Vertex.ccw(a, b, S))
+ dd = -dd;
+ if(dd < dist)
+ {
+ dist = dd;
+ found = pom;
+ int x1 = gr.x1;
+ int y1 = gr.y1;
+ int y2 = gr.y2;
+ gr.set(S, Math.abs(dist));
+ if(gr.x1 < x1 || gr.y1 < y1 || gr.y2 > y2)
+ {
+ i = gr.x1 - 1;
+ break label1;
+ }
+ }
+ }
+ }
+
+ setMark(i, j);
+ }
+
+ }
+
+ return found;
+ }
+
+ public QuadEdge findShortestCrossEdge(double med, int coord)
+ {
+ Vertex a = null;
+ Vertex b = null;
+ double d = 0.0D;
+ switch(coord)
+ {
+ case 0: // '\0'
+ for(int x = (int)((med - xoffset) / cellsize); a == null && x >= 0; x--)
+ {
+ for(int i = 0; i < ysize; i++)
+ {
+ for(PointIterator pi = cellIterator(x, i); pi.hasNext();)
+ {
+ Vertex pom = (Vertex)pi.next();
+ double dd = Math.abs(pom.x - med);
+ if(pom.x < med && (a == null || dd < d))
+ {
+ a = pom;
+ d = dd;
+ }
+ }
+
+ }
+
+ }
+
+ if(a == null)
+ return null;
+ int xmax = xsize;
+ for(int x = (int)((med - xoffset) / cellsize); b == null || x < xmax; x++)
+ {
+ for(int i = 0; i < ysize; i++)
+ {
+ for(PointIterator pi = cellIterator(x, i); pi.hasNext();)
+ {
+ Vertex pom = (Vertex)pi.next();
+ double dd = Vertex.distance(a, pom);
+ if(pom.x >= med && (b == null || dd < d))
+ {
+ b = pom;
+ d = dd;
+ xmax = (int)(((med + d) - xoffset) / cellsize) + 1;
+ if(xmax > xsize)
+ xmax = xsize;
+ }
+ }
+
+ }
+
+ }
+
+ break;
+
+ case 1: // '\001'
+ for(int y = (int)((med - yoffset) / cellsize); a == null && y >= 0; y--)
+ {
+ for(int i = 0; i < xsize; i++)
+ {
+ for(PointIterator pi = cellIterator(i, y); pi.hasNext();)
+ {
+ Vertex pom = (Vertex)pi.next();
+ double dd = Math.abs(pom.y - med);
+ if(pom.y < med && (a == null || dd < d))
+ {
+ a = pom;
+ d = dd;
+ }
+ }
+
+ }
+
+ }
+
+ if(a == null)
+ return null;
+ int ymax = ysize;
+ for(int y = (int)((med - yoffset) / cellsize); b == null || y < ymax; y++)
+ {
+ for(int i = 0; i < xsize; i++)
+ {
+ for(PointIterator pi = cellIterator(i, y); pi.hasNext();)
+ {
+ Vertex pom = (Vertex)pi.next();
+ double dd = Vertex.distance(a, pom);
+ if(pom.y >= med && (b == null || dd < d))
+ {
+ b = pom;
+ d = dd;
+ ymax = (int)(((med + d) - yoffset) / cellsize) + 1;
+ if(ymax > ysize)
+ ymax = ysize;
+ }
+ }
+
+ }
+
+ }
+
+ break;
+ }
+ if(b == null)
+ return null;
+ else
+ return QuadEdge.makeEdge(a, b);
+ }
+
+ private GridCell grid[][];
+ private PointItem array[];
+ private int xsize;
+ private int ysize;
+ private double xoffset;
+ private double yoffset;
+ private double cellsize;
+ private int currentMark;
+
+
+
+
+
+
+}
+
diff --git a/src/main/java/plugins/ragini/voronoidiagram/VRegion.java b/src/main/java/plugins/ragini/voronoidiagram/VRegion.java
new file mode 100644
index 0000000000000000000000000000000000000000..e95a35d6eb4544db8b2b51377506930d63912099
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/VRegion.java
@@ -0,0 +1,1071 @@
+ package plugins.ragini.voronoidiagram;
+import java.awt.geom.Line2D;
+import java.awt.geom.Point2D;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+
+
+public class VRegion {
+
+ private float pxmin = 10^10, pxmax = -1*(10^10), pymin = 10^10, pymax = -1 * (10^10);
+
+ private float[] xminymin, xminymax, xmaxymax, xmaxymin;
+
+ private float Pxmin, Pxmax, Pymin, Pymax;
+
+ private VertTheta[] corner;
+
+ private int numverts, numvedges, numtris;
+
+ private int[] inverse;
+
+ private VertTheta [] vtlist, slist;
+ private int vtnum;
+ private Integer[][] adjlist;
+
+ private int MAXVERTS;
+ private Constants constants;
+ private Vonoroi voronoi;
+ private ArrayList<Neighbor>[][] bins;
+ private VoronoiDiagram main;
+
+ private static final int SAFE = -900000;
+
+ public VRegion(Constants _constants, VoronoiDiagram v) {
+ xminymin = new float[3];
+ xminymax = new float[3];
+ xmaxymax = new float[3];
+ xmaxymin = new float[3];
+ vtlist = new VertTheta [1024];
+ slist = new VertTheta [1024];
+ adjlist = new Integer [MAXVERTS * 3][2];
+ corner = new VertTheta[4];
+ constants = _constants;
+ inverse = new int[constants.maxVerts()];
+ main = v;
+ }
+
+ public void setVoronoi(Vonoroi v) {
+ voronoi = v;
+ }
+
+ public void outSite(Site s) {
+
+ }
+
+ public void outBisector(Edge e) {
+ //System.out.println("triangle line: " + "(" + e.reg()[0].getCoord().X() + "," + e.reg()[1].getCoord().Y() + ")" + " (" + e.reg()[0].getCoord().X() + "," + e.reg()[1].getCoord().Y() + ")");
+ }
+
+ public void clipLine(Edge e, int origin) {
+ Site s1, s2;
+ Site r1, r2;
+ float x1, x2, y1, y2;
+
+ if (e.a() == 1 && e.b() >= 0) {
+ s1 = e.ep()[1];
+ //if (s1 == null) System.out.println("s1 null");
+ //else if (s1.getCoord() == null) System.out.println("s1 coord null");
+ //else System.out.println("s1: " + s1.getCoord().X() + " " + s1.getCoord().Y());
+ s2 = e.ep()[0];
+ //if (s2 == null) System.out.println("s2 null");
+ //else if (s2.getCoord() == null) System.out.println("s2 coord null");
+ //else System.out.println("s2: " + s2.getCoord().X() + " " + s1.getCoord().Y());
+ r1 = e.reg()[1];
+ r2 = e.reg()[0];
+ }
+
+ else {
+ s1 = e.ep()[0];
+ //if (s1 == null) System.out.println("s1 null");
+ //else if (s1.getCoord() == null) System.out.println("s1 coord null");
+ //else System.out.println("s1: " + s1.getCoord().X() + " " + s1.getCoord().Y());
+ s2 = e.ep()[1];
+ //if (s2 == null) System.out.println("s2 null");
+ //else if (s2.getCoord() == null) System.out.println("s2 coord null");
+ //else System.out.println("s2: " + s2.getCoord().X() + " " + s2.getCoord().Y());
+ r1 = e.reg()[0];
+ r2 = e.reg()[1];
+ }
+
+ if (s1 == null || s2 == null) {
+ NVert vA, vB;
+ int A, B;
+
+ A = r1.sitenbr();
+ B = r2.sitenbr();
+
+ vA = constants.chverts()[A];
+ vB = constants.chverts()[B];
+
+ vA.setOnHull(1);
+ vB.setOnHull(1);
+
+ if (vA.nbr1() == 1) {
+ vB.setNbr1(B);
+ }
+ else if (vA.nbr2() == -1) {
+ if(vA.nbr1() != B) {
+ vA.setNbr2(B);
+ }
+ }
+
+ if (vB.nbr1() == -1) {
+ vB.setNbr1(A);
+ }
+ else if (vB.nbr2() == -1) {
+ if (vB.nbr1() != A) {
+ vB.setNbr2(A);
+ }
+ }
+
+ }
+
+ if(e.a() == 1) {
+ y1 = pymin;
+ if (s1 != null && s1.getCoord().Y() > pymin) {
+ y1 = s1.getCoord().Y();
+ }
+ if (y1 > pymax) return;
+ x1 = e.c() - e.b()*y1;
+ y2 = pymax;
+ if (s2 != null && s2.getCoord().Y() < pymax) {
+ y2 = s2.getCoord().Y();
+ }
+ if (y2 < pymin) return;
+ x2 = e.c() - e.b()*y2;
+ if ((x1 > pxmax & x2 > pxmax) | (x1 < pxmin & x2 <pxmin)) {
+ return;
+ }
+ if (x1 > pxmax) {
+ x1 = pxmax;
+ y1 = (e.c()-x1)/e.b();
+ if (e.b() == 0) System.out.println("dividing by zero");
+
+ }
+ if (x1 < pxmin) {
+ x1 = pxmin;
+ y1 = (e.c() - x1)/e.b();
+ if (e.b() == 0) System.out.println("dividing by zero");
+ }
+ if (x2 > pxmax) {
+ x2 = pxmax;
+ y2 = (e.c() - x2)/e.b();
+ if (e.b() == 0) System.out.println("dividing by zero");
+ }
+ if (x2 < pxmin) {
+ x2 = pxmin;
+ y2 = (e.c() - x2)/e.b();
+ if (e.b() == 0) System.out.println("dividing by zero");
+ }
+ }
+ else {
+ x1 = pxmin;
+ if (s1 != null && s1.getCoord().X() > pxmin) {
+ x1 = s1.getCoord().X();
+ }
+ if (x1 > pxmax) return;
+ y1 = e.c() - e.a() * x1;
+ x2 = pxmax;
+ if (s2 != null && s2.getCoord().X() < pxmax) {
+ x2 = s2.getCoord().X();
+ }
+ if (x2 < pxmin) return;
+ y2 = e.c() - e.a() * x2;
+ if ((y1 > pymax & y2 > pymax) | (y1 < pymin & y2 < pymin)) return;
+ if (y1> pymax) {
+ y1 = pymax;
+ x1 = (e.c() - y1)/e.a();
+ if(e.a() == 0) System.out.println("dividing by zero");
+ }
+ if(y1 < pymin) {
+ y1 = pymin;
+ x1 = (e.c() - y1) /e.a();
+ if(e.a() == 0) System.out.println("dividing by zero");
+ }
+ if(y2 > pymax) {
+ y2 = pymax;
+ x2 = (e.c() - y2) /e.a();
+ if(e.a() == 0) System.out.println("dividing by zero");
+ }
+ if(y2 < pymin) {
+ y2 = pymin;
+ x2 = (e.c() - y2) /e.a();
+ if(e.a() == 0) System.out.println("dividing by zero");
+ }
+ }
+
+ //draw line(x1,y1,x2,y2)
+ //System.out.println("line: " + "(" + x1 + "," + y1 + ")" + " (" + x2 + "," + y2 + ")");
+ Point2D p1 = new Point2D.Double(x1, y1);
+ Point2D p2 = new Point2D.Double(x2, y2);
+ /*try {
+ Thread.sleep(2000);
+ } catch (InterruptedException e1) {
+ // TODO Auto-generated catch block
+ e1.printStackTrace();
+ }*/
+ constants.lines()[constants.lineindex()][0] = p1;
+ constants.lines()[constants.lineindex()][1] = p2;
+ constants.setlineindex(constants.lineindex() + 1);
+
+ if (constants.triangulate() == 0) {
+ constants.vedges()[numvedges] = new EdgeS();
+ constants.vedges()[numvedges].setx1(x1);
+ constants.vedges()[numvedges].sety1(y1);
+ constants.vedges()[numvedges].setx2(x2);
+ constants.vedges()[numvedges].sety2(y2);
+
+ constants.vedges()[numvedges].setnbr1(r1 != null ? r1.sitenbr() : SAFE);
+ constants.vedges()[numvedges].setnbr2(r2 != null ? r2.sitenbr() : SAFE-1);
+
+ if (r1 != null && r2 != null) {
+ constants.vedges()[numvedges].setxm(avg(r1.getCoord().X(), r2.getCoord().X()));
+ constants.vedges()[numvedges].setym(avg(r1.getCoord().Y(), r2.getCoord().Y()));
+ }
+
+ if(constants.vrdebug() == 1) {
+ ///System.out.println...
+ }
+
+ if (numvedges < constants.maxEdges()) numvedges++;
+ else {
+ System.out.println("edge list overflow!");
+ System.exit(-1);
+ }
+
+ }
+ return;
+
+ }
+
+ public float avg(float a, float b) {
+ return (a + b)/2;
+ }
+
+ public void outEP(Edge e, int origin) {
+
+ if(constants.triangulate() == 0) {
+ clipLine(e, origin);
+ }
+
+ if(constants.vrdebug() == 1) {
+ ///System.out.println...
+ }
+
+ }
+
+ public void outVertex (Site v) {
+
+ if(constants.triangulate() == 0) {
+ constants.verts()[numverts] = new Vert();
+ constants.verts()[numverts].setX(v.getCoord().X());
+ constants.verts()[numverts].setY(v.getCoord().Y());
+
+ if (numverts < constants.maxVerts()) numverts++;
+ else {
+ System.out.println("nvert list overflow");
+ System.exit(-1); //not sure if should use this
+ }
+
+ }
+
+ if(constants.vrdebug() == 1) {
+ ///System.out.println...
+ }
+
+ }
+
+ public int CHS_LEFTOF(float cx, float cy, float ax, float ay, float bx, float by) {
+
+ /* predicate: true iff point c leftof directed line ab */
+ /* observation: we should use two shortest disp vectors */
+
+ double dist_ab, dist_bc, dist_ca, max_dist;
+ double det_b, det_a, det_c;
+ double err_b, err_a, err_c;
+
+ if (ax == bx && ay == by) {
+ System.out.println("indeterminate line");
+ return 0;
+ }
+
+ if ((cx == ax && cy == ay) ||(cx == bx && cy == by))
+ return 0;
+
+ dist_ab = Math.sqrt((bx - ax)*(bx - ax) + (by - ay)*(by - ay));
+ dist_bc = Math.sqrt((cx - bx)*(cx - bx) + (cy - by)*(cy - by));
+ dist_ca = Math.sqrt((ax - cx)*(ax - cx) + (ay - cy)*(ay - cy));
+
+ max_dist = max(dist_ab, max(dist_bc, dist_ca));
+
+ if(max_dist == dist_bc) {
+ /* use a as a pivot point [ie., form (c-a) x (b-a)] */
+ det_a = (ax - cx) * (by - ay) - (ay - cy) * (bx - ax);
+ if (det_a == 0) return 0;
+ err_a = (Math.abs((ax - cx) * (by - ay)) + Math.abs((ay - cy) * (bx - ax)))/det_a;
+ if ((Math.abs(det_a) > (10^-6)) || (err_a < (10^-7))) {
+ return ((det_a > 0) ? 1 : 0);
+ }
+ else return 0;
+ }
+ else if (max_dist == dist_ca) {
+ /* use b as a pivot point [ie., form (a-b) x (c-b)] */
+ det_b = (cx - bx) * (ay - by) - (cy - by) * (ax - bx);
+ if (det_b == 0) return 0;
+ err_b = (Math.abs((cx - bx) * (ay - by)) + Math.abs((cy - by) * (ax - bx)))/det_b;
+ if ((Math.abs(det_b) > (10^-6)) || (err_b < (10^-7))) {
+ return ((det_b > 0) ? 1 : 0);
+ }
+ else return 0;
+ }
+ else if (max_dist == dist_ab) {
+ /* use c as a pivot point [ie., form (b-c) x (a-c)] */
+ det_c = (ax - cx) * (by - cy) - (ay - cy) * (bx - cx);
+ if (det_c == 0) {
+ return (0);}
+ err_c = (Math.abs((cx - ax) * (by - cy)) + Math.abs((cy - ay) * (bx - cx))) / det_c;
+ if ((Math.abs(det_c) > (10^-6)) || (err_c < (10^-7))) {
+ return ((det_c > 0)? 1 : 0); }
+ else {
+ return (0); }
+ }
+ else {
+ System.out.println("error max distance");
+ }
+ return -3;
+ }
+
+ public double max(double a, double b) {
+ return (a > b? a : b);
+ }
+
+ public float max(float a, float b) {
+ return (a > b? a : b);
+ }
+
+ public void outTriple(Neighbor s1, Neighbor s2, Neighbor s3) {
+
+ Vert tmp;
+ Tri tri = null;
+
+ if (constants.triangulate() == 1) {
+ if (numtris < constants.maxTris()) {
+ tri = new Tri();
+ }
+ else {
+ System.out.println("triangle list overflow");
+ System.exit(-1);
+ }
+
+ tri.setV1(new Vert(constants.sites()[s1.sitenbr()].getCoord().X(), constants.sites()[s1.sitenbr()].getCoord().Y()));
+ tri.setV2(new Vert(constants.sites()[s2.sitenbr()].getCoord().X(), constants.sites()[s2.sitenbr()].getCoord().Y()));
+ tri.setV3(new Vert(constants.sites()[s3.sitenbr()].getCoord().X(), constants.sites()[s3.sitenbr()].getCoord().Y()));
+
+ if (CHS_LEFTOF(tri.v3().X(), tri.v3().Y(), tri.v1().X(), tri.v1().Y(), tri.v2().X(), tri.v2().Y()) == 0) {
+ tmp = tri.v3();
+ tri.setV3(tri.v2());
+ tri.setV2(tmp);
+ }
+
+ if(constants.rng() == 1) {
+ ArrayList<EdgeRNG> lines = new ArrayList<EdgeRNG>();
+ lines.add(new EdgeRNG(s1, s2));
+ lines.add(new EdgeRNG(s2, s3));
+ lines.add(new EdgeRNG(s1, s3));
+ for (EdgeRNG e: lines) {
+ boolean keep = true;
+ int i = 0;
+ for(Neighbor n: e.endpoints()) {
+ int thisbinx = (int) (Math.floor(n.getCoord().X()/constants.getedgex())) -1;
+ if (thisbinx < 0) thisbinx = 0;
+ int thisbiny = (int) (Math.floor(n.getCoord().Y()/constants.getedgey())) -1;
+ if (thisbiny < 0) thisbiny = 0;
+ int numbinsx = (int) Math.ceil(e.length()/constants.getedgex()) + 3;
+ int numbinsy = (int) Math.ceil(e.length()/constants.getedgey()) + 3;
+ int bstartx = thisbinx - numbinsx;
+ if (bstartx < 0) bstartx = 0;
+ int bendx = thisbinx + numbinsx;
+ if (bendx > constants.maxbinx()) bendx = constants.maxbinx();
+ int bstarty = thisbiny - numbinsy;
+ if (bstarty < 0) bstarty = 0;
+ int bendy = thisbiny + numbinsy;
+ if (bendy> constants.maxbiny()) bendy = constants.maxbiny();
+ for (int bx = bstartx; bx < bendx; bx++) {
+ for (int by = bstarty; by < bendy; by++) {
+ ArrayList<Neighbor> test = bins[bx][by];
+ if (test != null) {
+ for (Neighbor t : test) {
+ if (t != e.endpoints().get(0)
+ && t != e.endpoints().get(1)) {
+ double dist = distance(n, t);
+ if (dist < e.length()) {
+ int otherend = (i == 0) ? 1: 0;
+ double dist2 = distance(e.endpoints().get(otherend), t);
+ if (dist2 < e.length()) keep = false;
+ }
+ }
+ }
+ }
+ }
+ }
+ i++;
+ }
+ if (keep == true) constants.relativeneighbors().add(e);
+ }
+ }
+
+ constants.tris()[numtris] = tri;
+ numtris++;
+
+ if (!s1.neighbors().contains(s2))
+ s1.addNeighbor(s2);
+ if (!s1.neighbors().contains(s3))
+ s1.addNeighbor(s3);
+ if (!s2.neighbors().contains(s1))
+ s2.addNeighbor(s1);
+ if (!s2.neighbors().contains(s3))
+ s2.addNeighbor(s3);
+ if (!s3.neighbors().contains(s1))
+ s3.addNeighbor(s1);
+ if (!s3.neighbors().contains(s2))
+ s3.addNeighbor(s2);
+
+ }
+ }
+
+ private double distance(Neighbor g1, Neighbor g2) {
+ return distance(g1.getCoord().X(), g1.getCoord().Y(), g2.getCoord().X(), g2.getCoord().Y());
+ }
+
+ private double distance(double ax, double ay, double bx, double by) {
+ return (Math.sqrt((bx - ax)*(bx - ax) + (by - ay)*(by - ay)));
+ }
+
+ public void vdInit() {
+ numtris = 0;
+ numvedges = 0;
+ numverts = 0;
+ }
+
+ public void emitSites(Site[] vsites, int nsites) {
+ //Printing some stuff...
+ //opening files
+ }
+
+ private class scomp implements Comparator<Neighbor> {
+
+ @Override
+ public int compare(Neighbor s1, Neighbor s2) {
+ if(s1.getCoord().Y() < s2.getCoord().Y()) return -1;
+ else if (s1.getCoord().Y() > s2.getCoord().Y()) return 1;
+ else if (s1.getCoord().X() < s2.getCoord().X()) return -1;
+ else if (s1.getCoord().X() > s2.getCoord().X()) return 1;
+ else return 0;
+ }
+
+ }
+
+ public void bBoxInit() {
+ int k;
+ float dx, dy, x, y;
+
+ constants.setvxmin(10^10);
+ constants.setvxmax(-1*(10^10));
+ constants.setvymin(10^10);
+ constants.setvymax(-1*(10^10));
+
+ Neighbor [] sites = new Neighbor[constants.nsites()];
+
+ //System.out.println("numsites: " + constants.nsites());
+ for (k = 0; k < constants.nsites(); k++) {
+ //set sites all the same as GLsites (right now, the data read directly from the image)
+
+ Point c = new Point();
+ x = constants.getGLSites()[k].X(); //System.out.println("glsitex: " + x);
+ y = constants.getGLSites()[k].Y(); //System.out.println("glsitey: " + y);
+ c.setX(x);
+ c.setY(y);
+ Neighbor s = new Neighbor();
+ s.setCoord(c);
+ s.setSiteNbr(k);
+ sites[k] = s;
+
+ //System.out.println("setting site: " + s.getCoord().X() + " " + s.getCoord().Y());
+
+ //find the current bounds
+
+ if(x < constants.vxmin()) {
+ constants.setvxmin(x);
+ }
+
+ if (y < constants.vymin()) {
+ constants.setvymin(y);
+ }
+
+ if (x > constants.vxmax()) {
+ constants.setvxmax(x);
+ }
+
+ if (y > constants.vymax()) {
+ constants.setvymax(y);
+ }
+
+ }
+
+ if(constants.rng() == 1) {
+ constants.setrelativeneighbors(new ArrayList<EdgeRNG>(constants.nsites() * 2));
+ int n = (int) Math.floor(Math.sqrt(constants.nsites()));
+ constants.setmaxbinx(n);
+ constants.setmaxbiny(n);
+ bins = new ArrayList[n][n];
+ int edgex = (int) Math.floor((constants.vxmax()-constants.vxmin())/n);
+ constants.setedgex(edgex);
+ int edgey = (int) Math.floor((constants.vymax()-constants.vymin())/n);
+ constants.setedgey(edgey);
+ int binx;
+ int biny;
+ for(Neighbor j: sites) {
+ binx = (int) (Math.floor(j.getCoord().X()/edgex)) -1;
+ if (binx < 0) binx = 0;
+ biny = (int) (Math.floor(j.getCoord().Y()/edgey)) -1;
+ if (biny < 0) biny = 0;
+ if (bins[binx][biny] == null) {
+ bins[binx][biny] = new ArrayList<Neighbor>();
+ }
+ bins[binx][biny].add(j);
+ }
+ }
+
+ scomp comp = new scomp();
+
+ Arrays.sort(sites, comp);
+
+ constants.setSites(sites);
+
+ if (constants.vrdebug() == 1) {
+ emitSites(constants.sites(), constants.nsites()); //print some stuff...
+ }
+
+ float epsilon = 1;
+
+ dx = constants.vxmax() - constants.vxmin();
+ dx = max(dx, epsilon);
+
+ dy = constants.vymax() - constants.vymin();
+ dy = max(dy, epsilon);
+
+ pxmin = (float) (constants.vxmin() - (dx*0.25));
+ pymin = (float) (constants.vymin() - (dy*0.25));
+ pxmax = (float) (constants.vxmax() + (dx*0.25));
+ pymax = (float) (constants.vymax() + (dy*0.25));
+
+ //Some more printing...
+
+ }
+
+ /* load_vsites():
+ accept the n voronoi sites (x_n, y_n)
+ calculate and store the voronoi diagram over the n sites,
+ clipping all infinite edges to bbox: [xmin, ymin, xmax, ymax].
+
+ note: if (xmin,ymin,xmax,ymax are all == 0.0), OR
+ if these do not enclose the data, a bounding box
+ will be computed over the input.
+
+ returns:
+ -1 if error
+ 0 otherwise
+*/
+
+ //usites = data from image
+ //n = number of data points?
+
+ public int loadVSites (int n, float[][] usites, float uxmin, float uymin, float uxmax, float uymax) {
+ int k, compute_bbox, sid; //tid;
+ float dx, dy; //x, y;
+
+ if (n >= constants.maxSites()) {
+ System.out.println("error too many sites");
+ return -1;
+ }
+
+ compute_bbox = ((uxmin == 0) && (uymin == 0) && (uxmax == 0) && (uymax == 0)) ? 1 : 0;
+
+ Vert[] USites = new Vert[n];
+ Vert[] GLSites = new Vert[n];
+ //NVert[] chverts = new NVert[constants.maxVerts()];
+ for (k = 0; k < n; k++) {
+ Vert v = new Vert();
+ v.setX(usites[k][0]);
+ //System.out.println("getting usites: " + usites[k][0] + " " + usites[k][1]);
+ v.setY(usites[k][1]);
+ USites[k] = v;
+ //System.out.println("set v: " + v.X() + " " + v.Y());
+ Vert r = new Vert();
+ r.setX(usites[k][0]);
+ r.setY(usites[k][1]);
+ GLSites[k] = r;
+
+ //System.out.println("setting glsite: " + r.X() + " " + r.Y());
+
+ //here, GLsites is the same as USites, which is just data read directly from the image
+ constants.chverts()[k] = new NVert();
+ constants.chverts()[k].setNbr1(-1);
+ constants.chverts()[k].setNbr2(-1); //what is the purpose of this?
+ constants.chverts()[k].setOnHull(0);
+ }
+
+ constants.setUSites(USites);
+ constants.setGLsites(GLSites);
+
+ constants.setNSites(n);
+ if (constants.nsites() <=2) {
+ for(k = 0; k < constants.nsites(); k++) {
+ constants.uchverts()[k].setVPid(k);
+ constants.uchverts()[k].setNbr1((k-1+constants.nsites()) % constants.nsites()); //what is the purpose of this?
+ constants.uchverts()[k].setNbr2((k+1+constants.nsites()) % constants.nsites());
+ }
+ return -3;
+ }
+
+ voronoi.sortGLSites(); //sort by data points and remove coincident sites
+
+ bBoxInit(); //set some bounds
+
+ /* now, if user punted on bbox calculation, OR if user bbox does not truly enclose
+ user data, we use our bbox (computed in initbbox). otherwise we take the user's. */
+
+ if (!(compute_bbox == 1 || uxmin > constants.vxmin() || uymin > constants.vymin() || uxmax < constants.vxmax() || uymax < constants.vymax())) {
+ //if we did not want to compute bbox or what the user gave (?) is larger than what was computed?
+ pxmin = uxmin;
+ pymin = uymin;
+ pxmax = uxmax;
+ pymax = uymax;
+ }
+
+ xminymax[0] = pxmin;
+ xminymin[0] = pxmin;
+ xminymin[1] = pymin;
+ xmaxymin[1] = pymin;
+
+ xmaxymax[0] = pxmax;
+ xmaxymin[0] = pxmax;
+ xmaxymax[1] = pymax;
+ xminymax[1] = pymax;
+
+ corner[0] = new VertTheta(xminymin[0], xminymin[1]);
+ corner[1] = new VertTheta(xmaxymin[0], xmaxymin[1]);
+ corner[2] = new VertTheta(xmaxymax[0], xmaxymax[1]);
+ corner[3] = new VertTheta(xminymax[0], xminymax[1]);
+
+ /* now: set the floating point tolerance values P*** to be 1 or 2 significant bits inside the p*** */
+ /* be careful to use RELATIVE error; that is, to scale the tolerance to the bbox values themselves */
+ /* now, if some user puts points way out in left field, our technique handles the ranges correctly */
+
+ dx = (pxmax - pxmin) * (1/4096);
+ dy = (pymax - pymin) * (1/4096);
+
+ //cut a little off the edges?
+
+ Pxmin = pxmin + dx;
+ Pxmax = pxmax - dx;
+ Pymin = pymin + dy;
+ Pymax = pymax - dy;
+
+ /* compute inverse of external->internal sid mapping */
+ /* given an internal site number, returns user index */
+
+ for (sid = 0; sid < constants.nsites(); sid++) {
+ inverse[sid] = constants.getGLSites()[sid].vpid(); //when did vpid get set and what is it?
+ }
+
+
+ //creating an inverse of some sort...?
+ /*for (sid = 0; sid < constants.nsites(); sid ++) {
+ if (constants.sites()[sid].getCoord().X() != constants.USites()[inverse[sid]].X())
+ System.out.println("inverse error");
+ if (constants.sites()[sid].getCoord().Y() != constants.USites()[inverse[sid]].Y())
+ System.out.println("inverse error");
+ }
+ */
+
+ vdInit(); //initialize counting numbers
+
+ /* run the voronoi code, no triangulate */
+ //constants.setTriangulate(0);
+ //voronoi.voronoi();
+
+ //bBoxInit();
+ //constants.setTriangulate(1);
+ //System.out.println("triangulate: " + constants.triangulate());
+ voronoi.voronoi();
+
+ for (sid = 0; sid < constants.nsites(); sid++) {
+ constants.sites()[sid].setSiteNbr(constants.getGLSites()[sid].vpid());
+ constants.sites()[sid].getCoord().setX(constants.getGLSites()[sid].X());
+ constants.sites()[sid].getCoord().setY(constants.getGLSites()[sid].Y());
+ }
+
+ return 0;
+
+ }
+
+ private class vtcomp implements Comparator<VertTheta> {
+
+ @Override
+ public int compare(VertTheta v1, VertTheta v2) {
+ if (v1.theta() < v2.theta()) {
+ return -1;
+ }
+ else if (v1.theta() > v2.theta()) {
+ return 1;
+ }
+ else return 0;
+ }
+
+ }
+
+ /*
+ find_vregion(sid, plen, pverts)
+ given a site id 'sid' from 0..nsites-1 inclusive,
+ returns the voronoi polygon associated with that site
+ in the array 'pverts', and its length on call stack.
+
+ the vertices are returned in counterclockwise order.
+
+ returns:
+ -1 if error condition
+ plen > 2 [i.e., the # of verts in the voronoi polygon] otherwise
+*/
+
+ public int findVRegion (int vsid, float[][] pverts) {
+
+ //given a site id, returns the voronoi polygon associated with that site, with the vertices returned in counterclockwise order
+
+ int sid, b, k, vnum, bnd1, bnd2, bdiff, sleft, lag, lead, p1a, p1b, p2a, p2b;
+ float x, y, x1, y1, x2, y2, theta1, theta2, lasttheta, dtheta, h;
+
+ //ifdef statement here - but the identifier is never actually defined in the code, so perhaps it is not needed?
+
+ if (vsid < 0 || vsid >= constants.nsites()){
+ System.out.println("error site bounds");
+ return -1;
+ }
+
+ for (sid = 0; sid < constants.nsites(); sid++) {
+ if (constants.getGLSites()[sid].vpid() == vsid)
+ break;
+ }
+
+ if (sid == constants.nsites()) {
+ System.out.println("can't find requested site");
+ return -1;
+ }
+
+ for (k = 0; k < 4; k++) {
+ corner[k].setTheta((float) Math.atan2((double) (corner[k].Y() - constants.getGLSites()[sid].Y()), (double) (corner[k].X() - constants.getGLSites()[sid].X())));
+ }
+
+ vtnum = 0;
+ for (k = 0; k < numvedges; k++) {
+ if (constants.vedges()[k].nbr1() == sid) {
+ slist[vtnum].setE1(k);
+ slist[vtnum].setE2(k);
+ slist[vtnum].setTheta((float) Math.atan2((double) (constants.vedges()[k].y1() - constants.getGLSites()[sid].Y()), (double) (constants.vedges()[k].x1() - constants.getGLSites()[sid].X())));
+ slist[vtnum].setX(constants.vedges()[k].x1());
+ slist[vtnum].setY(constants.vedges()[k].y1());
+
+ vtnum ++;
+
+ slist[vtnum].setE1(k);
+ slist[vtnum].setE2(k);
+ slist[vtnum].setTheta((float) Math.atan2((double) (constants.vedges()[k].y2() - constants.getGLSites()[sid].Y()), (double) (constants.vedges()[k].x2() - constants.getGLSites()[sid].X())));
+ slist[vtnum].setX(constants.vedges()[k].x2());
+ slist[vtnum].setY(constants.vedges()[k].y2());
+
+ }
+ }
+
+ vtcomp comp = new vtcomp();
+
+ Arrays.sort(slist, comp);
+
+ lag = 0;
+ lead = 0;
+
+ vtlist[lag] = slist[lead];
+ lasttheta = -10;
+
+ while (lead < vtnum) {
+ if (Math.abs((slist[lead].theta()- lasttheta)) > (10^-4)) {
+ lasttheta = slist[lead].theta();
+ vtlist[lag] = slist[lead];
+ lag++;
+ lead++;
+ }
+ else {
+ vtlist[lag-1].setE2(slist[lead].e1());
+ lead++;
+ }
+ }
+
+ vtnum = lag;
+
+ vnum = 0;
+ for(k = 0; k < vtnum; k++) {
+ if (Math.abs(vtlist[(k + vtnum - 1) % vtnum].theta() - vtlist[k].theta()) < (10^-4)){
+ System.out.println("region identical");
+ return -1;
+ }
+
+ x1 = vtlist[(k + vtnum - 1) % vtnum].X();
+ y1 = vtlist[(k + vtnum - 1) % vtnum].Y();
+ p1a = vtlist[(k + vtnum - 1) % vtnum].e1();
+ p1b = vtlist[(k + vtnum - 1) % vtnum].e2();
+ x2 = vtlist[k].X();
+ y2 = vtlist[k].Y();
+ p2a = vtlist[k].e1();
+ p2b = vtlist[k].e2();
+
+ if (((p1a == p2a) || (p1a == p2b) || (p1b == p2b)) && (vtnum > 2)) {
+ sid = PUTV(vtlist[k], sid, pverts);
+ }
+ else {
+ bnd1 = NBOUND(x1, y1);
+ bnd2 = NBOUND(x2, y2);
+
+ if (bnd1 >= 0 && bnd2 >=0)
+ bdiff = ((bnd2 - bnd1) + 4) % 4;
+ else
+ bdiff = 0;
+
+ if (bdiff == 0) {
+ sid = PUTV(vtlist[k], sid, pverts);
+ }
+ else {
+ if (vtnum == 2) {
+ theta1 = vtlist[0].theta();
+ theta2 = vtlist[1].theta();
+ dtheta = theta2 - theta1;
+
+ for(b = 0; b < 4; b++){
+ if ( /*dtheta >= M_PI*/ (corner[b].theta() > theta1) && (corner[b].theta() < theta2)) { //theta is the angle measure?
+ vtlist[vtnum++] = corner[b];
+ }
+ else if ( /*dtheta < M_PI*/ ((corner[b].theta() < theta1) || corner[b].theta() > theta2)) {
+ vtlist[vtnum++] = corner[b];
+ }
+ }
+
+ Arrays.sort(vtlist, comp);
+
+ for(b = 0; b < vtnum; b++) {
+ sid = PUTV(vtlist[b], sid, pverts);
+ }
+
+ break;
+
+ }
+
+ for (b = 0; b < bdiff; b++) {
+ sid = PUTV(corner[(bnd1 + b) % 4], sid, pverts);
+ }
+
+ sid = PUTV(vtlist[k], sid, pverts);
+ }
+ }
+ }
+
+ return vnum;
+
+ }
+
+ private int NBOUND(float x, float y) {
+ return (x >= Pxmax ? constants.rbnd() : (x <= Pxmin ? constants.lbnd() : (y >= Pymax ? constants.tbnd() : (y <= Pymin ? constants.bbnd() : -1))));
+ }
+
+ private int PUTV(VertTheta v, int vid, float[][] pverts) {//////////////////
+ pverts[vid][0] = v.X();
+ pverts[vid][1] = v.Y();
+ return (vid + 1);
+ }
+
+ public int findDTriangles () {///////////////////
+ if (numtris <= 0){
+ constants.setdtris(null);
+ return -1;
+ }
+ else {
+ Tri[] dtris = new Tri[constants.maxTris()];
+ int i = 0;
+ for (Tri t: constants.tris()) {
+ dtris[i] = t;
+ i++;
+ }
+ constants.setdtris(dtris);
+ return numtris;
+ }
+ }
+
+ private boolean EMATCH(Vert Ap, Vert Aq, Vert Bp, Vert Bq) {
+ return (Ap == Bp && Aq == Bq);
+ }
+
+ public int findDTAdjacencies (IntArraySetter dtadjset) {
+ int nadj = 0, j, k, nematched;
+ Tri trij, trik;
+
+ if (numtris <= 0) {
+ dtadjset.set(null);
+ return -1;
+ }
+ else {
+ for (j = 0; j < numtris; j++) {
+ trij = constants.tris()[j];
+ nematched = 0;
+ for (k = j + 1; k < numtris; k++) {
+ trik = constants.tris()[k];
+ if (EMATCH(trij.v1(), trij.v2(), trik.v3(), trik.v2()) || EMATCH(trij.v1(), trij.v2(), trik.v2(), trik.v1()) || EMATCH(trij.v1(), trij.v2(), trik.v1(), trik.v3())) {
+ adjlist[nadj][0] = j;
+ adjlist[nadj++][1] = k;
+ nematched++;
+ }
+ else if (EMATCH(trij.v2(), trij.v3(), trik.v3(), trik.v2()) || EMATCH(trij.v1(), trij.v3(), trij.v2(), trik.v1()) || EMATCH(trij.v2(), trij.v3(), trik.v1(), trik.v3())) {
+ adjlist[nadj][0] = j;
+ adjlist[nadj++][1] = k; //what does the ++ denote?
+ nematched++;
+ }
+ else if (EMATCH(trij.v3(), trij.v1(), trik.v3(), trik.v2()) || EMATCH(trij.v3(), trij.v1(), trik.v2(), trik.v1()) || EMATCH(trij.v3(), trij.v1(), trik.v1(), trik.v3())) {
+ adjlist[nadj][0] = j;
+ adjlist[nadj++][1] = k;
+ nematched++;
+ }
+ if (nematched == 3)
+ break;
+ }
+ }
+ dtadjset.set(adjlist); //this should maybe be the other way around?
+ return nadj;
+ }
+
+ }
+
+ public int fident(float a, float b) {
+ float sum;
+
+ sum = Math.abs(a) + Math.abs(b);
+ if (sum == 0)
+ return 1;
+ else {
+ sum = (a-b)/sum;
+ return ((sum > (2*(10^-7)) ? 1 : 0));
+ }
+
+ }
+
+ public int xycollinear (float ax, float ay, float bx, float by, float cx, float cy) {
+ float AX, AY, BX, BY;
+
+ AX = bx - ax;
+ AY = by - ay;
+ BX = cx - bx;
+ BY = cy - by;
+
+ return fident(AX*BY, BX*AY);
+
+ }
+
+ public int findConvexHull(ArraySetter chvertset) { //type of chvertices??
+ int k, nchverts, nbr1, nbr2;
+ NVert v1 = null, v2, T;
+ int start, lag, lead;
+
+ if (constants.nsites() <= 2) {
+ chvertset.set(constants.uchverts());
+ return constants.nsites();
+ }
+
+ for(k = 0; k < constants.nsites(); k++) {
+ v1 = constants.chverts()[k];
+ if (v1.onhull() == 1 && v1.nbr1() != -1 && v1.nbr2() != -1) {
+ break;
+ }
+ }
+ if (k == constants.nsites()) {
+ System.out.println("no hull edge found");
+ chvertset.set(null);
+ return -1;
+ }
+
+ start = v1.vpid();
+ lag = v1.vpid();
+ lead = v1.nbr2();
+
+ k = 0;
+
+ while(lag != start) {
+ if (k>0)
+ constants.uchverts()[k].setNbr1(constants.uchverts()[k-1].vpid());
+ constants.uchverts()[k].setVPid(inverse[lag]);
+ constants.uchverts()[k++].setNbr2(inverse[lead]);
+
+ if (lag == constants.chverts()[lead].nbr1()) {
+ lag = lead;
+ lead = constants.chverts()[lead].nbr2();
+ }
+ else if (lag == constants.chverts()[lead].nbr2()) {
+ lag = lead;
+ lead = constants.chverts()[lead].nbr1();
+ }
+ else {
+ System.out.println("inconsistent convex hull");
+ return 0;
+ }
+
+ }
+
+ constants.uchverts()[0].setNbr1(constants.uchverts()[k-1].vpid());
+ nchverts = k;
+
+ lag = 0;
+ for (k = 0; k < nchverts; k++) {
+ if ((fident(UX(k), UX((k + 1) % nchverts)) != 1 && fident(UY(k), UY((k + 1) % nchverts)) == 1)) {
+ constants.uchverts()[lag++] = constants.uchverts()[k];
+ }
+ if (lag != nchverts) {
+ System.out.println("excised coincident convex hull vertices");
+ k = lag;
+ nchverts = lag;
+ }
+ }
+
+ if (nchverts > 2) {
+ lag = 0;
+ for (k = 0; k < nchverts; k++) {
+ if (xycollinear(UX(k), UY(k), UX((k + 1) % nchverts), UY((k + 1) % nchverts), UX((k + 2) % nchverts), UY((k + 2) % nchverts)) == 0) {
+ constants.uchverts()[lag++] = constants.uchverts()[k];
+ }
+ }
+ if (lag != nchverts) {
+ System.out.println ("excised dgenerate convex hull edges");
+ k = lag;
+ nchverts = lag;
+ }
+ }
+
+ chvertset.set(constants.uchverts());
+ return k;
+
+ }
+
+ public float UX(int k) {
+ return constants.USites()[constants.uchverts()[k].vpid()].X();
+ }
+
+ public float UY(int k) {
+ return constants.USites()[constants.uchverts()[k].vpid()].Y();
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Vert.java b/src/main/java/plugins/ragini/voronoidiagram/Vert.java
new file mode 100644
index 0000000000000000000000000000000000000000..72a1807bd7bbfd39b0e197b6bba984620ad5bd57
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Vert.java
@@ -0,0 +1,19 @@
+package plugins.ragini.voronoidiagram;
+
+public class Vert extends Point {
+
+ private int vpid;
+
+ public Vert(float _x, float _y) {
+ x = _x;
+ y = _y;
+ }
+
+ public Vert() {
+ }
+
+ public int vpid() {
+ return vpid;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/VertTheta.java b/src/main/java/plugins/ragini/voronoidiagram/VertTheta.java
new file mode 100644
index 0000000000000000000000000000000000000000..199945d414d48d6f166e7183e1d316da578c2532
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/VertTheta.java
@@ -0,0 +1,53 @@
+package plugins.ragini.voronoidiagram;
+
+public class VertTheta {
+
+ private float x, y, theta;
+ private int e1, e2;
+
+ public VertTheta(float _x, float _y) {
+ x = _x;
+ y = _y;
+ }
+
+ public float theta() {
+ return theta;
+ }
+
+ public void setTheta(float t) {
+ theta = t;
+ }
+
+ public float Y() {
+ return y;
+ }
+
+ public float X() {
+ return x;
+ }
+
+ public int e1() {
+ return e1;
+ }
+
+ public int e2() {
+ return e2;
+ }
+
+ public void setE1(int e) {
+ e1 = e;
+ }
+
+ public void setE2(int e) {
+ e2 = e;
+ }
+
+ public void setX(float _x) {
+ x = _x;
+ }
+
+ public void setY(float _y) {
+ y = _y;
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Vertex.java b/src/main/java/plugins/ragini/voronoidiagram/Vertex.java
new file mode 100644
index 0000000000000000000000000000000000000000..2e586b2023a72bde7204208ec854b0091b62455e
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Vertex.java
@@ -0,0 +1,218 @@
+package plugins.ragini.voronoidiagram;
+//Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
+//Jad home page: http://www.kpdus.com/jad.html
+//Decompiler options: packimports(3)
+//Source File Name: Vertex.java
+
+
+import java.io.Serializable;
+
+//Referenced classes of package delaunay:
+// DT
+
+public class Vertex
+ implements Serializable
+{
+
+ public Vertex(double x, double y)
+ {
+ visit = false;
+ this.x = x;
+ this.y = y;
+ }
+
+ public Vertex(double x, double y, int indice)
+ {
+ this(x, y);
+ setIndice(indice);
+ }
+
+ public void setIndice(int indice)
+ {
+ this.indice = indice;
+ }
+
+ public static double distance(Vertex a, Vertex b)
+ {
+ if(a == DT.vertex_infty || b == DT.vertex_infty)
+ return DT.MAX_VALUE;
+ else
+ return Math.sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
+ }
+
+ public static double sqrDistance(Vertex a, Vertex b)
+ {
+ if(a == DT.vertex_infty || b == DT.vertex_infty)
+ return DT.MAX_VALUE;
+ else
+ return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
+ }
+
+ public static boolean colinear(Vertex a, Vertex b, Vertex c)
+ {
+ return (a.x * (b.y - c.y) - a.y * (b.x - c.x)) + (b.x * c.y - b.y * c.x) == 0.0D;
+ }
+
+ public boolean test(double med, int coord)
+ {
+ if(coord == 0)
+ return x >= med;
+ return y >= med;
+ }
+
+ public static boolean ccw(Vertex a, Vertex b, Vertex c)
+ {
+ return (a.x * (b.y - c.y) - a.y * (b.x - c.x)) + (b.x * c.y - b.y * c.x) > 0.0D;
+ }
+
+ public boolean ccw(Vertex b, Vertex c)
+ {
+ return (x * (b.y - c.y) - y * (b.x - c.x)) + (b.x * c.y - b.y * c.x) > 0.0D;
+ }
+
+ public static Vertex findCenter(Vertex A, Vertex B, Vertex C)
+ {
+ DT.counter2++;
+ double aux = (((-B.x * C.y + B.x * A.y + A.x * C.y) - A.x * B.y) + B.y * C.x) - A.y * C.x;
+ if(aux == 0.0D)
+ {
+ return DT.vertex_infty;
+ } else
+ {
+ double ss = ((((-B.x * A.x - B.x * C.x) + A.x * C.x) - B.y * A.y - B.y * C.y) + A.y * C.y + B.x * B.x + B.y * B.y) / aux;
+ return new Vertex(((A.x + C.x) - ss * (C.y - A.y)) / 2D, ((A.y + C.y) - ss * (A.x - C.x)) / 2D);
+ }
+ }
+
+ public static Vertex findBary(Vertex A, Vertex B, Vertex C)
+ {
+ return new Vertex((A.x + C.x + B.x) / 3D, (A.y + C.y + B.y) / 3D);
+ }
+
+ public static double delaunayDistance(Vertex A, Vertex B, Vertex C)
+ {
+ Vertex S = findCenter(A, B, C);
+ double ss = sqrDistance(S, A);
+ if(ccw(A, B, C))
+ {
+ if(!ccw(A, B, S))
+ ss = -ss;
+ } else
+ if(ccw(A, B, S))
+ ss = -ss;
+ return ss;
+ }
+
+ public boolean inCircle(Vertex a, Vertex b, Vertex c, Vertex d)
+ {
+ if(a == d || b == d || c == d)
+ return false;
+ DT.counter2++;
+ double d02 = a.x * a.x + a.y * a.y;
+ double d12 = b.x * b.x + b.y * b.y;
+ double d22 = c.x * c.x + c.y * c.y;
+ double d32 = d.x * d.x + d.y * d.y;
+ double det = a.x * det3x3(b.y, d12, 1.0D, c.y, d22, 1.0D, d.y, d32, 1.0D);
+ det -= a.y * det3x3(b.x, d12, 1.0D, c.x, d22, 1.0D, d.x, d32, 1.0D);
+ det += d02 * det3x3(b.x, b.y, 1.0D, c.x, c.y, 1.0D, d.x, d.y, 1.0D);
+ det -= det3x3(b.x, b.y, d12, c.x, c.y, d22, d.x, d.y, d32);
+ return det > 0.0D;
+ }
+
+ public boolean inCircle(Vertex b, Vertex c, Vertex d)
+ {
+ if(this == d || b == d || c == d)
+ return false;
+ DT.counter2++;
+ double d02 = x * x + y * y;
+ double d12 = b.x * b.x + b.y * b.y;
+ double d22 = c.x * c.x + c.y * c.y;
+ double d32 = d.x * d.x + d.y * d.y;
+ double det = x * det3x3(b.y, d12, 1.0D, c.y, d22, 1.0D, d.y, d32, 1.0D);
+ det -= y * det3x3(b.x, d12, 1.0D, c.x, d22, 1.0D, d.x, d32, 1.0D);
+ det += d02 * det3x3(b.x, b.y, 1.0D, c.x, c.y, 1.0D, d.x, d.y, 1.0D);
+ det -= det3x3(b.x, b.y, d12, c.x, c.y, d22, d.x, d.y, d32);
+ return det > 0.0D;
+ }
+
+ public static double det3x3(double d00, double d01, double d02, double d10,
+ double d11, double d12, double d20, double d21, double d22)
+ {
+ return (d00 * (d11 * d22 - d12 * d21) - d01 * (d10 * d22 - d12 * d20)) + d02 * (d10 * d21 - d11 * d20);
+ }
+
+ public static void mergeSort(Vertex s[])
+ {
+ mergeSort(s, 0, s.length);
+ }
+
+ public static void mergeSort(Vertex s[], int a, int b)
+ {
+ int size = b - a;
+ if(size > 1)
+ if(size == 2)
+ {
+ if(compare(s[a], s[a + 1]))
+ {
+ Vertex tmp = s[a];
+ s[a] = s[a + 1];
+ s[a + 1] = tmp;
+ }
+ } else
+ {
+ int mid = size / 2;
+ mergeSort(s, a, a + mid);
+ mergeSort(s, a + mid, b);
+ Vertex ascend[] = new Vertex[size];
+ int i = a;
+ int j = a + mid;
+ for(int k = 0; k < size; k++)
+ if(i >= a + mid)
+ ascend[k] = s[j++];
+ else
+ if(j >= b)
+ ascend[k] = s[i++];
+ else
+ if(compare(s[i], s[j]))
+ ascend[k] = s[j++];
+ else
+ ascend[k] = s[i++];
+
+ for(int k = 0; k < size; k++)
+ s[a + k] = ascend[k];
+
+ }
+ }
+
+ public void setVisit()
+ {
+ visit = true;
+ }
+
+ public void setVisit(boolean visit)
+ {
+ this.visit = visit;
+ }
+
+ public boolean getVisit()
+ {
+ return visit;
+ }
+
+ public static boolean compare(Vertex s1, Vertex s2)
+ {
+ if(s1.x != s2.x)
+ return s1.x > s2.x;
+ return s1.y > s2.y;
+ }
+
+ public String toString()
+ {
+ return (new StringBuilder(" ")).append(indice).append(" ").toString();
+ }
+
+ double x;
+ double y;
+ int indice;
+ boolean visit;
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/Vonoroi.java b/src/main/java/plugins/ragini/voronoidiagram/Vonoroi.java
new file mode 100644
index 0000000000000000000000000000000000000000..a825c69e5407074819e75eee1863424618c7c0a6
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/Vonoroi.java
@@ -0,0 +1,295 @@
+package plugins.ragini.voronoidiagram;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Vonoroi
+{
+
+ private int siteidx, nvertices;
+
+ HalfEdge PQHash;
+
+ private Constants constants;
+
+ private EdgeList edgelist;
+ private VRegion vregion;
+ private Geometry events;
+
+ public Vonoroi(EdgeList _edgelist, Constants _constants, VRegion _vregion, Geometry geometry)
+ {
+ siteidx = 0;
+ constants = _constants;
+ edgelist = _edgelist;
+ vregion = _vregion;
+ events = geometry;
+ }
+
+ private class GLscomp implements Comparator<Vert>
+ {
+
+ @Override
+ public int compare(Vert s1, Vert s2)
+ {
+ if (s1.Y() < s2.Y())
+ return -1;
+ else if (s1.Y() > s2.Y())
+ return 1;
+ else if (s1.X() < s2.X())
+ return -1;
+ else if (s1.X() > s2.X())
+ return 1;
+ else
+ return 0;
+ }
+
+ }
+
+ public void sortGLSites()
+ {
+
+ float vx, vy;
+ int k, sid;
+ char a;
+ float dx, dy;
+
+ GLscomp comp = new GLscomp();
+
+ Arrays.sort(constants.getGLSites(), comp);
+
+ // excise();
+
+ }
+
+ // private void excise() {
+ //
+ // int sid = 0;
+ // Vert[] GLSites = constants.getGLSites();
+ //
+ // for(int k = 0; k < constants.nsites(); k++) {
+ // if (k ==0 || (GLSites[k-1].Y() != GLSites[k].Y()) || (GLSites[k-1].X() != GLSites[k].X())) {
+ //
+ // dx = GLSites[k].x * (1.0 / 4096.0);
+ // dy = GLSites[k].y * (1.0 / 4096.0);
+ //
+ // /* GLSites[sid].setX(GLSites[k].X());
+ // GLSites[sid].setY(GLSites[k].Y()); */
+ // }
+ // }
+ //
+ // if (sid != constants.nsites()) {
+ // System.out.printf("voronoi: excised %d coincident sites\n", constants.nsites()-sid);
+ // }
+ //
+ // }
+
+ public void voronoi()
+ {
+ SiteProvider sp = new SiteProvider(constants);
+
+ Neighbor newsite, temp, p, v;
+ Neighbor bot, top;
+ Point newintstar = new Point();
+ int pm;
+ HalfEdge lbnd, rbnd, llbnd, rrbnd, bisector;
+ Edge e;
+
+ if (constants.nsites() <= 1)
+ return;
+ geominit();
+ events.PQinitialize();
+
+ constants.setBottomSite(sp.next());
+ vregion.outSite(constants.bottomsite()); // print some stuff and draw a circle
+ // circle(...s)
+ edgelist.ELinitialize();
+
+ newsite = sp.next();
+
+ // System.out.println("initialized");
+
+ // when do values get added to the hash table?
+ while (true)
+ {
+ if (!events.PQempty())
+ newintstar = events.PQmin();
+
+ // newsite is above (greater priority) than the minimum event in the queue
+ if (newsite != null
+ && (events.PQempty() || (newsite.getCoord().Y() < newintstar.Y()) || (newsite.getCoord().Y() == newintstar
+ .Y() && newsite.getCoord().X() < newintstar.X())))
+ {
+ // System.out.println("newsite is smallest");
+ vregion.outSite(newsite); // print some stuff and draw a circle with pre-defined
+ // radius
+ lbnd = edgelist.ELleftbnd(newsite.getCoord()); // retrieve the halfedge from the
+ // hash table
+ rbnd = edgelist.ELright(lbnd);
+ bot = edgelist.rightReg(lbnd); // ?
+ e = edgelist.bisect(bot, newsite);
+
+ bisector = edgelist.HEcreate(e, constants.le(), 0); // create a new half edge from
+ // the bisector?
+ edgelist.ELinsert(lbnd, bisector); // insert it into the hash table? or the linear
+ // list?
+ if ((p = (Neighbor) edgelist.sintersect(lbnd, bisector)) != null)
+ {
+ events.PQdelete(lbnd);
+ events.PQinsert(lbnd, p, dist(p, newsite));
+ }
+ lbnd = bisector;
+ bisector = edgelist.HEcreate(e, constants.re(), 0);
+ edgelist.ELinsert(lbnd, bisector);
+ if ((p = (Neighbor) edgelist.sintersect(bisector, rbnd)) != null)
+ {
+ events.PQinsert(bisector, p, dist(p, newsite));
+ }
+ newsite = sp.next();
+ }
+ else if (!events.PQempty())
+ {
+ // System.out.println("newintstar is smallest");
+ lbnd = events.PQextractmin();
+ /*
+ * if (lbnd.eledge() == null) System.out.println("lbnd: null edge");
+ * else System.out.println("lbnd: " + lbnd.eledge().a() + ", " + lbnd.eledge().b() +
+ * ", " + lbnd.eledge().c());
+ */
+ llbnd = edgelist.ELleft(lbnd);
+ // if (llbnd.eledge() == null) System.out.println("llbnd: null edge");
+ // else System.out.println("llbnd: " + llbnd.eledge().a() + ", " +
+ // llbnd.eledge().b() + ", " + llbnd.eledge().c());
+ rbnd = edgelist.ELright(lbnd);
+ // if (rbnd.eledge() == null) System.out.println("rbnd: null edge");
+ // else System.out.println("rbnd: " + rbnd.eledge().a() + ", " + rbnd.eledge().b() +
+ // ", " + rbnd.eledge().c());
+ rrbnd = edgelist.ELright(rbnd);
+ // if (rrbnd.eledge() == null) System.out.println("rrbnd: null edge");
+ // else System.out.println("rrbnd: " + rrbnd.eledge().a() + ", " +
+ // rrbnd.eledge().b() + ", " + rrbnd.eledge().c());
+ bot = edgelist.leftReg(lbnd);
+ top = edgelist.rightReg(rbnd);
+ // System.out.println("bot: " + bot.getCoord().X() + " " + bot.getCoord().Y());
+ // System.out.println("top: " + top.getCoord().X() + " " + top.getCoord().Y());
+ vregion.outTriple(bot, top, edgelist.rightReg(lbnd)); // this is where the
+ // triangulate variable is
+ // used, just printing some
+ // stuff
+ v = (Neighbor) lbnd.vertex();
+ // if (v == null)
+ // System.out.println("vertex null");
+ // else System.out.println("vertex: " + v.getCoord().X() + " " + v.getCoord().Y());
+ makevertex(v);
+ // System.out.println("made vertex");
+ edgelist.v_endpoint(lbnd.eledge(), 1, lbnd.elpm(), v);
+ edgelist.v_endpoint(rbnd.eledge(), 1, rbnd.elpm(), v);
+ // System.out.println("called vendpoint");
+ edgelist.ELdelete(lbnd);
+ //
+ events.PQdelete(rbnd);
+ edgelist.ELdelete(rbnd);
+ /*
+ * System.out.println("printing list");
+ * for(HalfEdge cur = edgelist.leftend(); cur != edgelist.rightend(); cur =
+ * edgelist.ELright(cur)) {
+ * e = cur.eledge();
+ * if (e == null) System.out.println("null edge");
+ * else System.out.println("edge: " + e.a() + " " + e.b() + " " + e.c());
+ * if (cur.right() == edgelist.rightend()) {
+ * System.out.println("reached right end"); e = cur.right().eledge(); if (e != null)
+ * System.out.println("right end: " + e.a() + " " + e.b() + " " + e.c());}
+ * }
+ * System.out.println("done printing list");
+ * if (rbnd.eledge() == null) System.out.println("deleted null edge");
+ * else System.out.println("deleted: " + rbnd.eledge().a() + ", " +
+ * rbnd.eledge().b() + ", " + rbnd.eledge().c());
+ */
+ pm = constants.le();
+
+ if ((bot.getCoord().Y() > top.getCoord().Y())
+ || ((bot.getCoord().Y() == top.getCoord().Y()) && (bot.getCoord().X() > top.getCoord().X())))
+ {
+ temp = bot;
+ bot = top;
+ top = temp;
+ pm = constants.re();
+ }
+
+ //
+
+ e = edgelist.bisect(bot, top);
+
+ bisector = edgelist.HEcreate(e, pm, 1);
+ edgelist.ELinsert(llbnd, bisector);
+ /*
+ * System.out.println("right : " + bisector.right().eledge().a() + ", " +
+ * bisector.right().eledge().b() + ", " + bisector.right().eledge().c());
+ * if (bisector.right().right().eledge() == null) System.out.println("rright null");
+ * else System.out.println("rright: " + bisector.right().right().eledge().a() + ", "
+ * + bisector.right().right().eledge().b() + ", " +
+ * bisector.right().right().eledge().c());
+ */
+ edgelist.v_endpoint(e, 1, constants.re() - pm, v);
+ if ((p = (Neighbor) edgelist.sintersect(llbnd, bisector)) != null)
+ {
+ events.PQdelete(llbnd);
+ // if (lbnd.eledge() == null) System.out.println("deleted null edge");
+ // else System.out.println("deleted: " + lbnd.eledge().a() + ", " +
+ // lbnd.eledge().b() + ", " + lbnd.eledge().c());
+ events.PQinsert(llbnd, p, dist(p, bot));
+ }
+
+ if ((p = (Neighbor) edgelist.sintersect(bisector, rrbnd)) != null)
+ {
+ events.PQinsert(bisector, p, dist(p, bot));
+ }
+ }
+ else
+ { // System.out.println("break voronoi");
+ break;
+ }
+ }
+
+ for (lbnd = edgelist.ELright(edgelist.leftend()); lbnd != edgelist.rightend(); lbnd = edgelist.ELright(lbnd))
+ {
+ e = lbnd.eledge();
+ // System.out.println("printing edge: " + e.a() + " " + e.b() + " " + e.c());
+ vregion.outEP(e, lbnd.origin());// calls clipline, which draws the appropriate line
+ // if (lbnd.right() == edgelist.rightend()) System.out.println("reached right end");
+ }
+
+ }
+
+ public void makevertex(Site v)
+ {
+ v.setSiteNbr(nvertices);
+ nvertices += 1;
+ vregion.outVertex(v); // /print some stuff
+ }
+
+ private void geominit()
+ {
+ nvertices = 0;
+ constants.setnedges(0);
+ float sn = constants.nsites() + 4;
+ constants.setsqrtnsites(Math.sqrt(sn));
+ // System.out.println("setting sqrt" + constants.sqrtnsites());
+ constants.setvdeltay(constants.vymax() - constants.vymin());
+ constants.setvdeltax(constants.vxmax() - constants.vxmin());
+ }
+
+ public float dist(Site a, Site b)
+ {
+ float ax, bx, ay, by;
+
+ ax = a.getCoord().X();
+ ay = a.getCoord().Y();
+
+ bx = b.getCoord().X();
+ by = b.getCoord().Y();
+
+ return (float) Math.sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay));
+
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/VoronoiDiagram.java b/src/main/java/plugins/ragini/voronoidiagram/VoronoiDiagram.java
new file mode 100644
index 0000000000000000000000000000000000000000..51fffad3a07d198202a1992162d0035fc5572b77
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/VoronoiDiagram.java
@@ -0,0 +1,561 @@
+package plugins.ragini.voronoidiagram;
+
+import icy.canvas.IcyCanvas;
+import icy.image.IcyBufferedImage;
+import icy.painter.AbstractPainter;
+import icy.painter.Painter;
+import icy.painter.PainterListener;
+import icy.roi.BooleanMask2D;
+import icy.roi.ROI2DEllipse;
+import icy.roi.ROI2DLine;
+import icy.roi.ROI2DPoint;
+import icy.roi.ROI2DPolygon;
+import icy.sequence.Sequence;
+import icy.type.DataType;
+import icy.type.collection.array.Array1DUtil;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Polygon;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.MouseEvent;
+import java.awt.geom.Ellipse2D;
+import java.awt.geom.Point2D;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+
+import jxl.NumberCell;
+import jxl.Sheet;
+import jxl.Workbook;
+import jxl.read.biff.BiffException;
+
+import plugins.adufour.blocks.lang.Block;
+import plugins.adufour.blocks.util.VarList;
+import plugins.adufour.ezplug.EzButton;
+import plugins.adufour.ezplug.EzPlug;
+import plugins.adufour.ezplug.EzVar;
+import plugins.adufour.ezplug.EzVarEnum;
+import plugins.adufour.ezplug.EzVarFile;
+import plugins.adufour.ezplug.EzVarInteger;
+import plugins.adufour.ezplug.EzVarListener;
+import plugins.adufour.ezplug.EzVarSequence;
+import plugins.adufour.vars.lang.VarSequence;
+
+public class VoronoiDiagram extends EzPlug implements Block {
+
+ private enum MethodType
+ {
+ DELAUNAY("Calculate Delaunay Triangulation"), VORONOI("Calculate Voronoi Diagram"), RNG("Calculate Relative Neighborhood Graph");
+
+ private final String name;
+
+ private MethodType(String string)
+ {
+ this.name = string;
+ }
+
+ public String toString()
+ {
+ return this.name;
+ }
+ }
+
+ private Constants constants;
+ private EzVarFile input = new EzVarFile("Input", "/Users");
+ private EzVarSequence img = new EzVarSequence("Image");
+ private EzVarInteger numPoints = new EzVarInteger("Display Closest Points", 2, 1, 7, 1);
+ private EzButton morphbutton = new EzButton("Calculate Morphological Operators", new buttonlist());
+
+ private class buttonlist implements ActionListener {
+
+ @Override
+ public void actionPerformed(ActionEvent arg0) {
+
+ a = new Alpha_Morph(constants.sites(), constants.vxmin(), constants.vymin(), constants.vxmax(), constants.vymax());
+ }
+
+ }
+
+ float[][] points;
+ VarSequence out = new VarSequence("Out", null);
+ Point2D[] dpoints;
+ private EzVarEnum<MethodType> method = new EzVarEnum<MethodType>("Method:", MethodType.values()); ;
+
+ private ArrayList<ROI2DSite> imgpoints = new ArrayList<ROI2DSite>();
+ private ArrayList<ROI2DSite> allpoints = new ArrayList<ROI2DSite>();
+ private ArrayList<ROI2DLine> alltris = new ArrayList<ROI2DLine>();
+ private ArrayList<ROI2DLine> imgedges = new ArrayList<ROI2DLine>();
+ private Sequence seqOut;
+ private Alpha_Morph a;
+
+ @Override
+ public void clean() {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ protected void execute() {
+ String data = input.getValue().getPath();
+ MethodType _method = method.getValue();
+ Sequence seqIn = img.getValue();
+ final int numpoints = numPoints.getValue();
+ IcyBufferedImage imgIn = null;
+ if (seqIn != null) {
+ imgIn = seqIn.getImage(0, 0, 0); }
+ System.out.println(_method.toString());
+ points = new float[5000][2];
+ dpoints = new Point2D[5000];
+ double xmin = 0;
+ double xmax = 0;
+ double ymin = 0;
+ double ymax = 0;
+ int x = 0;
+ try {
+ Workbook wb = Workbook.getWorkbook(new File(data));
+ Sheet s = wb.getSheet(0);
+ NumberCell c = (NumberCell) s.getCell(0,0);
+ while (x < s.getRows()) {
+ c = (NumberCell) s.getCell(0,x);
+ points[x][0] = (float) c.getValue();
+ c = (NumberCell) s.getCell(1,x);
+ points[x][1] = (float) c.getValue();
+ dpoints[x] = new Point2D.Double(points[x][0], points[x][1]);
+ //System.out.println("x: " + points[x][0] + "y: " + points[x][1]);
+ if (x == 0 ){
+ xmin = points[x][0];
+ xmax = points[x][0];
+ ymin = points[x][1];
+ ymax = points[x][1];
+ }
+ else {
+ if (points[x][0] > xmax)
+ xmax = points[x][0];
+ if (points[x][0] < xmin)
+ xmin = points[x][0];
+ if (points[x][1] > ymax)
+ ymax = points[x][1];
+ if (points[x][1] < ymin)
+ ymin = points[x][1];
+ }
+ x++;
+ }
+ //System.out.println("done reading data points");
+ } catch (BiffException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+
+ constants= new Constants();
+ if(_method.toString() == "Calculate Delaunay Triangulation") {
+ constants.setTriangulate(1);
+ }
+ else if(_method.toString() == "Calculate Relative Neighborhood Graph") {
+ constants.setTriangulate(1);
+ constants.setrng(1);
+ }
+ VRegion vregion = new VRegion(constants, this);
+ EdgeList EL = new EdgeList(constants, vregion);
+ Geometry events = new Geometry(constants);
+ Vonoroi voronoi = new Vonoroi(EL, constants, vregion, events);
+ vregion.setVoronoi(voronoi);
+ seqOut = new Sequence();
+ if (seqIn == null) {
+ int width = (int) Math.ceil(xmax - xmin + 1);
+ int height = (int) Math.ceil(ymax - ymin + 1);
+ IcyBufferedImage imgOut = new IcyBufferedImage(width,height, 1, DataType.UBYTE );
+ seqOut.addImage(imgOut);
+ double[] _out = Array1DUtil.arrayToDoubleArray(imgOut.getDataXY(0), imgOut.isSignedDataType());
+ for (int p = 0; p < width; p++) {
+ for (int q = 0; q < height; q++) {
+ _out[p + q*width] = 255;
+ }
+ }
+ imgOut.setDataXY(0,Array1DUtil.doubleArrayToArray(_out, imgOut.getDataXY(0)));
+ seqOut.setImage(0, 0, imgOut);}
+ else {seqOut.setImage(0, 0, imgIn);seqOut.dataChanged(); }
+for(int k= 0; k < x; k++) {
+
+ Point2D dp = new Point2D.Double(points[k][0], points[k][1]);
+ ROI2DSite point = new ROI2DSite(dp);
+ allpoints.add(point);
+ point.setEditable(false);
+ point.setColor(Color.ORANGE);
+ point.attachTo(seqOut);
+
+ }
+ vregion.loadVSites(x, points, 0, 0, 0, 0);
+
+
+ //System.out.println("done running");
+
+
+
+ int i = 0;
+ Point2D p1;
+ while((p1 = constants.lines()[i][0]) != null) {
+ Point2D p2 = constants.lines()[i][1];
+ ROI2DLine line = new ROI2DLine(p1, p2);
+ line.setEditable(false);
+ line.setColor(Color.CYAN);
+ line.attachTo(seqIn);
+ i++;
+ }
+
+ i= 0;
+ Vert v;
+ while ((v = constants.verts()[i]) != null) {
+ Point2D p = new Point2D.Double(v.X(), v.Y());
+ ROI2DPoint point = new ROI2DPoint(p);
+ point.setEditable(false);
+ point.setColor(Color.RED);
+ point.attachTo(seqOut);
+ i++;
+ }
+
+ long dist[]=new long[1000]; //VMY
+
+ if (constants.triangulate() == 1 && constants.rng() != 1) {
+ alltris.clear();
+ i = 0;
+ Tri t;
+ while ((t = constants.tris()[i]) != null) {
+ Point2D t1 = new Point2D.Double(t.v1().X(), t.v1().Y());
+ Point2D t2 = new Point2D.Double(t.v2().X(), t.v2().Y());
+ Point2D t3 = new Point2D.Double(t.v3().X(), t.v3().Y());
+
+ ROI2DLine l1 = new ROI2DLine(t1, t2);
+ ROI2DLine l2 = new ROI2DLine(t2, t3);
+ ROI2DLine l3 = new ROI2DLine(t1, t3);
+
+ l1.setEditable(false);
+ l1.setColor(Color.GREEN);
+ l1.attachTo(seqIn);
+ l2.setEditable(false);
+ l2.setColor(Color.GREEN);
+ l2.attachTo(seqIn);
+ l3.setEditable(false);
+ l3.setColor(Color.GREEN);
+ l3.attachTo(seqIn);
+
+ double d1 = t1.distance(t2);
+ int d = (int) (Math.round(Math.floor(d1)));
+ // System.out.println(" "+d1+" d:"+d+" t1x:"+t1.getX()+" t1y:"+t1.getY());
+ // dist[d]++;
+ double d2 = t1.distance(t3);
+ d = (int) (Math.round(Math.floor(d2))); // d1 ??
+ // System.out.println(" "+d2+" d:"+d +" t2x:"+t2.getX()+" t2y:"+t2.getY());
+ // dist[d]++;
+ double d3 = t2.distance(t3);
+ d = (int) (Math.round(Math.floor(d3))); // d3?
+ // System.out.println(" "+d3+" d:"+d+" t3x:"+t3.getX()+" t3y:"+t3.getY());
+ // dist[d]++;
+
+ //MYV
+ Polygon polygon = new Polygon();
+ polygon.addPoint(
+ (int) t1.getX(),
+ (int) t1.getY()
+ );
+ polygon.addPoint(
+ (int) t2.getX(),
+ (int) t2.getY()
+ );
+ polygon.addPoint(
+ (int) t3.getX(),
+ (int) t3.getY()
+ );
+
+
+ ROI2DPolygon poly = new ROI2DPolygon();
+ poly.setPolygon(polygon);
+
+ BooleanMask2D roiMask = poly.getAsBooleanMask();
+
+ int minx = Math.max(0, roiMask.bounds.x);
+ int maxx = Math.min(4000, roiMask.bounds.x+roiMask.bounds.width);
+ int miny = Math.max(0, roiMask.bounds.y);
+ int maxy = Math.min(4000, roiMask.bounds.y+roiMask.bounds.height);
+ double intensitySpot=0.;
+ int areaC=0;//size Cell
+ for (int ix = minx; ix < maxx;ix++)
+ for (int y = miny; y < maxy;y++){
+ if(roiMask.contains(ix, y)) {
+ areaC++;
+ }
+
+ }
+ System.out.println(" "+areaC); // triangle Size
+
+
+
+
+ alltris.add(l1);
+ alltris.add(l2);
+ alltris.add(l3);
+
+ /*Circ c = makeCirc(t1, t2, t3);
+ ROI2DEllipse circ = new ROI2DEllipse(c.rectangle());
+ circ.setEditable(false);
+ circ.setColor(Color.ORANGE);
+ circ.attachTo(seqOut);*/
+
+ //System.out.println("tri: " + "(" + t1.getX() + "," + t1.getY() + ") (" + t2.getX() + "," + t2.getY() + ") (" + t3.getX() + "," + t3.getY() + ")");
+ /*ArrayList<Point2D> plist = new ArrayList<Point2D>();
+ plist.add(t1);
+ plist.add(t2);
+ plist.add(t3);
+ ROI2DPolygon tri = new ROI2DPolygon();
+ alltris.add(tri);
+ tri.setPoints(plist);
+ tri.setColor(Color.GREEN);
+ tri.setEditable(false);
+ tri.attachTo(seqOut); */
+ /*Circ c = makeCirc(t1, t2, t3);
+ Point2D ref;
+ if (t1.getX() > t2.getX()) {
+ ref = t1;
+ }
+ else ref = t2;
+ if (t3.getX() > ref.getX()) ref = t3;
+ Ellipse2D e = new Ellipse2D.Double(ref.getX(), ref.getY(), c.r()*2, c.r()*2);
+ ROI2DEllipse re = new ROI2DEllipse(e.getFrame());
+ re.setColor(Color.BLUE);
+ re.setEditable(false);
+ re.attachTo(seqOut); */
+ i++;
+ }
+ }
+
+ else if (constants.rng() == 1) {
+ i = 0;
+ for (EdgeRNG e: constants.relativeneighbors()) {
+ ROI2DEdge edge = new ROI2DEdge(e);
+ edge.setEditable(false);
+ edge.setColor(Color.YELLOW);
+ edge.attachTo(seqOut);
+ }
+
+ }
+ allpoints.clear();
+ for(Neighbor site : constants.sites()) {
+
+ Point2D dp = new Point2D.Double(site.getCoord().X(), site.getCoord().Y());
+ ROI2DSite point = new ROI2DSite(dp);
+ point.setSite(site);
+ site.setPoint(point);
+ allpoints.add(point);
+ point.setEditable(false);
+ point.setColor(Color.ORANGE);
+ point.attachTo(seqOut);
+ }
+
+
+
+ if (_method.toString() == "Calculate Delaunay Triangulation") {
+ Painter painter = new AbstractPainter() {
+ @Override
+ public void mousePressed(MouseEvent e, Point2D imagePoint,
+ IcyCanvas canvas) {
+ //super.mouseClick(e, imagePoint, canvas);
+ //System.out.println("mouse pressed");
+ for(ROI2DSite p : allpoints) {
+ if ((p.getPoint().getX() <= imagePoint.getX() + 3 && p.getPoint().getX() >= imagePoint.getX() -3) && ((p.getPoint().getY() <= imagePoint.getY() + 3) && p.getPoint().getY() >= imagePoint.getY() -3)) {
+ //System.out.println("on site");
+ p.setColor(Color.RED);
+ Neighbor sp = (Neighbor) p.getSite();
+ int size = sp.neighbors().size();
+ //System.out.println(size);
+ int count = 0;
+ Neighbor cur = null;
+ ArrayList<Neighbor> temp = new ArrayList<Neighbor>();
+ //System.out.println("size: " + size);
+ //System.out.println("numpoints: " + numpoints);
+ while (count < numpoints && count < size) {
+ cur = sp.neighbors().remove();
+ temp.add(cur);
+ ROI2DSite curpoint = cur.getPoint();
+ curpoint.setColor(Color.YELLOW);
+ imgpoints.add(curpoint);
+ count++;
+ if (count == 1) {
+ for (Neighbor s : cur.samedistpoints()) {
+ if (sp.neighbors().remove(s)) {
+ s.getPoint().setColor(Color.YELLOW);
+ imgpoints.add(s.getPoint());
+ temp.add(s);
+ count++;
+ }
+ }
+ }
+ }
+ for (Neighbor t : temp) {
+ sp.addNeighbor(t);
+ }
+ temp.clear();
+ boolean incident = false;
+ boolean keep = false;
+ for(ROI2DLine edge: alltris) {
+ Point2D tp = edge.getLine().getP1();
+ if (tp.getX() == p.getPoint().getX() && tp.getY() == p.getPoint().getY()){
+ incident = true; //System.out.println("incident");
+ }
+
+ tp = edge.getLine().getP2();
+ if (tp.getX() == p.getPoint().getX() && tp.getY() == p.getPoint().getY()){
+ incident = true; //System.out.println("incident");
+ }
+
+ for (ROI2DSite n: imgpoints) {
+ tp = edge.getLine().getP1();
+
+ if (tp.getX() == n.getPoint().getX() && tp.getY() == n.getPoint().getY()) {
+ if (incident == true) {keep = true; }
+ }
+
+
+ tp = edge.getLine().getP2();
+
+ if (tp.getX() == n.getPoint().getX() && tp.getY() == n.getPoint().getY()) {
+ if (incident == true) {keep = true;}
+ }
+
+
+
+ }
+ for (Neighbor t : temp) {
+ sp.addNeighbor(t);
+ }
+ temp.clear();
+ //System.out.println("keep: " + keep);
+ if (keep == false) {
+ edge.detachFrom(seqOut);
+ imgedges.add(edge);
+ }
+ keep = false;
+ incident = false;
+ }
+
+ imgpoints.add(p);
+ }
+ }
+
+
+ }
+
+ @Override
+ public void mouseReleased(MouseEvent e, Point2D imagePoint,
+ IcyCanvas canvas) {
+ for(ROI2DSite rp : imgpoints) {
+ rp.setColor(Color.BLACK);
+ }
+ imgpoints.clear();
+ for(ROI2DLine edge: imgedges) {
+ edge.attachTo(seqOut);
+ }
+ imgedges.clear();
+
+
+ }
+
+ };
+
+
+ seqOut.addPainter(painter);
+ seqOut.painterChanged(painter);
+ }
+
+ if (isHeadLess()) {
+ out.setValue(seqOut);
+ }
+
+ else {addSequence(seqOut);}
+
+ }
+
+ private Circ makeCirc(Point2D p1, Point2D p2, Point2D p3) {
+ double x = (p3.getX()*p3.getX() * (p1.getY() - p2.getY())
+ + (p1.getX()*p1.getX() + (p1.getY() - p2.getY())*(p1.getY() - p3.getY()))
+ * (p2.getY() - p3.getY()) + p2.getX()*p2.getX() * (-p1.getY() + p3.getY()))
+ / (2 * (p3.getX() * (p1.getY() - p2.getY()) + p1.getX() * (p2.getY() - p3.getY()) + p2.getX()
+ * (-p1.getY() + p3.getY())));
+
+ double y = (p2.getY() + p3.getY())/2 - (p3.getX() - p2.getX())/(p3.getY() - p2.getY())
+ * (x - (p2.getX() + p3.getX())/2);
+
+ Point2D c = new Point2D.Double(x,y);
+ double r = distance(c.getX(), c.getY(), p1.getX(), p1.getY());
+
+ return (new Circ(c, r));
+
+ }
+
+ private double distance(double ax, double ay, double bx, double by) {
+ return (Math.sqrt((bx - ax)*(bx - ax) + (by - ay)*(by - ay)));
+ }
+
+ @Override
+ protected void initialize() {
+
+ super.addEzComponent(input);
+ super.addEzComponent(img);
+ super.addEzComponent(method);
+ super.addEzComponent(numPoints);
+ super.addEzComponent(morphbutton);
+ method.addVarChangeListener(new EzVarListener<MethodType>()
+ {
+ @Override
+ public void variableChanged(EzVar<MethodType> source, MethodType newValue)
+ {
+ updateDefaultParams();
+ }
+
+ });
+
+
+ }
+
+ @Override
+ public void declareInput(VarList inputMap) {
+ inputMap.add(input.getVariable());
+ inputMap.add(method.getVariable());
+ inputMap.add(img.getVariable());
+ inputMap.add(numPoints.getVariable());
+ }
+
+ @Override
+ public void declareOutput(VarList outputMap) {
+ outputMap.add(out);
+ }
+
+ private void updateDefaultParams()
+ {
+ if (true)
+ {
+ /*if (input.getValue(false) != null)
+ {*/
+ MethodType _method = method.getValue();
+ switch(_method)
+ {
+ case DELAUNAY:
+
+ break;
+ case VORONOI:
+
+ break;
+ default:
+ break;
+ }
+
+ //}
+ }
+ }
+
+}
diff --git a/src/main/java/plugins/ragini/voronoidiagram/dkmax.java b/src/main/java/plugins/ragini/voronoidiagram/dkmax.java
new file mode 100644
index 0000000000000000000000000000000000000000..300b59d07347af12e8e42d335d073b042c1058fc
--- /dev/null
+++ b/src/main/java/plugins/ragini/voronoidiagram/dkmax.java
@@ -0,0 +1,8 @@
+package plugins.ragini.voronoidiagram;
+
+public class dkmax {
+
+ private int id;
+ private int max;
+
+}