java – 仅渲染与主圆相交的圆的线段/区域

Java 前端之家
前端之家收集整理的这篇文章主要介绍了java – 仅渲染与主圆相交的圆的线段/区域，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

我绝对喜欢数学(或者你们大多数人都会说’数学’！)但是我还没有达到我知道这个问题答案的水平.我有一个主圆,可以在显示屏上的任何x和y处有一个中心点.其他圆圈将随意在显示器周围移动,但在任何给定的渲染方法调用中,我不仅要渲染与主圆相交的圆,而且只渲染在主圆内可见的圆的线段.类比将是对现实生活对象的阴影,我只想绘制那个被“照亮”的对象的一部分.

我想最好用Java做这个,但如果你有一个原始的公式,将不胜感激.我想知道如何绘制形状并用Java填充它,我确定曲线上的折线必须有一些变化吗？

非常感谢

最佳答案
设A和B为2 intersection points(当没有或1个截取点时,你可以忽略它).

然后计算A和B之间circular line segment的长度.

有了这些信息,您应该能够使用Graphics' drawArc(...)方法绘制弧线(如果我没有弄错……).

编辑

好吧,你甚至不需要圆形线段的长度.我有线交叉代码,所以我围绕它构建了一个小GUI,你可以如何绘制/查看这些相交圆的ARC(代码中有一些注释)：

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.*;
  4. import java.awt.geom.Arc2D;
  6. /**
  7.  * @author: Bart Kiers
  8.  */
  9. public class GUI extends JFrame {
  11.     private GUI() {
  12.         super("Circle Intersection Demo");
  13.         initGUI();
  14.     }
  16.     private void initGUI() {
  17.         super.setSize(600,640);
  18.         super.setDefaultCloSEOperation(EXIT_ON_CLOSE);
  19.         super.setLayout(new BorderLayout(5,5));
  21.         final Grid grid = new Grid();
  23.         grid.addMouseMotionListener(new MouseMotionAdapter() {
  24.             @Override
  25.             public void mouseDragged(MouseEvent e) {
  26.                 Point p = new Point(e.getX(),e.getY()).toCartesianPoint(grid.getWidth(),grid.getHeight());
  27.                 grid.showDraggedCircle(p);
  28.             }
  29.         });
  31.         grid.addMouseListener(new MouseAdapter() {
  32.             @Override
  33.             public void mouseReleased(MouseEvent e) {
  34.                 Point p = new Point(e.getX(),grid.getHeight());
  35.                 grid.released(p);
  36.             }
  38.             @Override
  39.             public void mousePressed(MouseEvent e) {
  40.                 Point p = new Point(e.getX(),grid.getHeight());
  41.                 grid.pressed(p);
  42.             }
  43.         });
  45.         super.add(grid,BorderLayout.CENTER);
  46.         super.setVisible(true);
  47.     }
  49.     public static void main(String[] args) {
  50.         SwingUtilities.invokeLater(new Runnable() {
  51.             @Override
  52.             public void run() {
  53.                 new GUI();
  54.             }
  55.         });
  56.     }
  58.     private static class Grid extends JPanel {
  60.         private Circle c1 = null;
  61.         private Circle c2 = null;
  62.         private Point screenClick = null;
  63.         private Point currentPosition = null;
  65.         public void released(Point p) {
  66.             if (c1 == null || c2 != null) {
  67.                 c1 = new Circle(screenClick,screenClick.distance(p));
  68.                 c2 = null;
  69.             } else {
  70.                 c2 = new Circle(screenClick,screenClick.distance(p));
  71.             }
  72.             screenClick = null;
  73.             repaint();
  74.         }
  76.         public void pressed(Point p) {
  77.             if(c1 != null && c2 != null) {
  78.                 c1 = null;
  79.                 c2 = null;
  80.             }
  81.             screenClick = p;
  82.             repaint();
  83.         }
  85.         @Override
  86.         public void paintComponent(Graphics g) {
  88.             Graphics2D g2d = (Graphics2D) g;
  89.             g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
  91.             g2d.setColor(Color.WHITE);
  92.             g2d.fillRect(0,super.getWidth(),super.getHeight());
  94.             final int W = super.getWidth();
  95.             final int H = super.getHeight();
  96.             g2d.setColor(Color.LIGHT_GRAY);
  97.             g2d.drawLine(0,H / 2,W,H / 2); // x-axis
  98.             g2d.drawLine(W / 2,W / 2,H); // y-axis
  100.             if (c1 != null) {
  101.                 g2d.setColor(Color.RED);
  102.                 c1.drawOn(g2d,H);
  103.             }
  105.             if (c2 != null) {
  106.                 g2d.setColor(Color.ORANGE);
  107.                 c2.drawOn(g2d,H);
  108.             }
  110.             if (screenClick != null && currentPosition != null) {
  111.                 g2d.setColor(Color.DARK_GRAY);
  112.                 g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,0.5f));
  113.                 Circle temp = new Circle(screenClick,screenClick.distance(currentPosition));
  114.                 temp.drawOn(g2d,H);
  115.                 currentPosition = null;
  116.             }
  118.             if (c1 != null && c2 != null) {
  120.                 g2d.setColor(Color.BLUE);
  121.                 g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,0.4f));
  122.                 Point[] ips = c1.intersections(c2);
  123.                 for (Point ip : ips) {
  124.                     ip.drawOn(g,H);
  125.                 }
  126.                 g2d.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER,0.2f));
  127.                 if (ips.length == 2) {
  128.                     g2d.setStroke(new BasicStroke(10.0f));
  129.                     c1.highlightArc(g2d,ips[0],ips[1],H);
  130.                 }
  131.             }
  133.             g2d.dispose();
  134.         }
  136.         public void showDraggedCircle(Point p) {
  137.             currentPosition = p;
  138.             repaint();
  139.         }
  140.     }
  142.     private static class Circle {
  144.         public final Point center;
  145.         public final double radius;
  147.         public Circle(Point center,double radius) {
  148.             this.center = center;
  149.             this.radius = radius;
  150.         }
  152.         public void drawOn(Graphics g,int width,int height) {
  153.             // translate Cartesian(x,y) to Screen(x,y)
  154.             Point screenP = center.toScreenPoint(width,height);
  155.             int r = (int) Math.rint(radius);
  156.             g.drawOval((int) screenP.x - r,(int) screenP.y - r,r + r,r + r);
  158.             // draw the center
  159.             Point screenCenter = center.toScreenPoint(width,height);
  160.             r = 4;
  161.             g.drawOval((int) screenCenter.x - r,(int) screenCenter.y - r,r + r);
  162.         }
  164.         public void highlightArc(Graphics2D g2d,Point p1,Point p2,int height) {
  166.             double a = center.degrees(p1);
  167.             double b = center.degrees(p2);
  169.             // translate Cartesian(x,height);
  170.             int r = (int) Math.rint(radius);
  172.             // find the point to start drawing our arc
  173.             double start = Math.abs(a - b) < 180 ? Math.min(a,b) : Math.max(a,b);
  175.             // find the minimum angle to go from `start`-angle to the other angle
  176.             double extent = Math.abs(a - b) < 180 ? Math.abs(a - b) : 360 - Math.abs(a - b);
  178.             // draw the arc
  179.             g2d.draw(new Arc2D.Double((int) screenP.x - r,start,extent,Arc2D.OPEN));
  180.         }
  182.         public Point[] intersections(Circle that) {
  184.             // see: http://mathworld.wolfram.com/Circle-CircleIntersection.html
  185.             double d = this.center.distance(that.center);
  186.             double d1 = ((this.radius * this.radius) - (that.radius * that.radius) + (d * d)) / (2 * d);
  187.             double h = Math.sqrt((this.radius * this.radius) - (d1 * d1));
  188.             double x3 = this.center.x + (d1 * (that.center.x - this.center.x)) / d;
  189.             double y3 = this.center.y + (d1 * (that.center.y - this.center.y)) / d;
  190.             double x4_i = x3 + (h * (that.center.y - this.center.y)) / d;
  191.             double y4_i = y3 - (h * (that.center.x - this.center.x)) / d;
  192.             double x4_ii = x3 - (h * (that.center.y - this.center.y)) / d;
  193.             double y4_ii = y3 + (h * (that.center.x - this.center.x)) / d;
  195.             if (Double.isNaN(x4_i)) {
  196.                 // no intersections
  197.                 return new Point[0];
  198.             }
  200.             // create the intersection points
  201.             Point i1 = new Point(x4_i,y4_i);
  202.             Point i2 = new Point(x4_ii,y4_ii);
  204.             if (i1.distance(i2) < 0.0000000001) {
  205.                 // i1 and i2 are (more or less) the same: a single intersection
  206.                 return new Point[]{i1};
  207.             }
  209.             // two unique intersections
  210.             return new Point[]{i1,i2};
  211.         }
  213.         @Override
  214.         public String toString() {
  215.             return String.format("{center=%s,radius=%.2f}",center,radius);
  216.         }
  217.     }
  219.     private static class Point {
  221.         public final double x;
  222.         public final double y;
  224.         public Point(double x,double y) {
  225.             this.x = x;
  226.             this.y = y;
  227.         }
  229.         public double degrees(Point that) {
  230.             double deg = Math.toDegrees(Math.atan2(that.y - this.y,that.x - this.x));
  231.             return deg < 0.0 ? deg + 360 : deg;
  232.         }
  234.         public double distance(Point that) {
  235.             double dX = this.x - that.x;
  236.             double dY = this.y - that.y;
  237.             return Math.sqrt(dX * dX + dY * dY);
  238.         }
  240.         public void drawOn(Graphics g,y)
  241.             Point screenP = toScreenPoint(width,height);
  242.             int r = 7;
  243.             g.fillOval((int) screenP.x - r,r + r);
  244.         }
  246.         public Point toCartesianPoint(int width,int height) {
  247.             double xCart = x - (width / 2);
  248.             double yCart = -(y - (height / 2));
  249.             return new Point(xCart,yCart);
  250.         }
  252.         public Point toScreenPoint(int width,int height) {
  253.             double screenX = x + (width / 2);
  254.             double screenY = -(y - (height / 2));
  255.             return new Point(screenX,screenY);
  256.         }
  258.         @Override
  259.         public String toString() {
  260.             return String.format("(%.2f,%.2f)",x,y);
  261.         }
  262.     }
  263. }

如果您启动上面的GUI,然后在文本框中键入100 0 130 -80 55 180并点击return,您将看到以下内容：…

更改了代码,以便通过按下并拖动鼠标来绘制圆圈.截图：

circle

猜你在找的Java相关文章

ArrayList源码分析
ArrayList简介：ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的...
java多线程与并发（基础篇）
一、进程与线程 进程：是代码在数据集合上的一次运行活动，是系统进行资源分配和调度的基本...
LinkedList 的实现原理
本文为博客园作者所写：&#160;一寸HUI，个人博客地址：https://www.cnblogs.com/zsql/...
java之面向对象详解
#############java面向对象详解#############1、面向对象基本概念2、类与对象3、类和对象的...
java之异常详解
一、什么是异常? 异常就是有异于常态，和正常情况不一样，有错误出错。在java中，阻止当前...
Map的四种遍历
//Map的四种遍历方法 //Map不能直接遍历 ，只能通过遍历Key与Value间接遍历 public static...
throw和throws的区别以及try,catch,finally在有return的情况下执行的顺序
一，抛出异常有三种形式，一是throw,一个throws，还有一种系统自动抛异常。下面它们之间的...
Jdk14 都要出了，Jdk9 的新特性还不了解一下？
中最大的亮点是 Java 平台模块化 的引入，以及模块化 JDK。但是 还有很多其他新功能，这篇...
还看不懂同事代码？快来补一波 Java 7 语法特性
Jdk 频繁更新，新特性了解吗？每次更新都注重提高生产效率，提高 JVM 性能，推行模块化等，...
Java 12 新特性介绍，快来补一补
Java 12 早在 2019 年 3 月 19 日发布，这些新特性你知道吗
PHPJavaJava SEPythonC#C&C++RubyVBasp.NetGoPerlnettyDjangoDelphiJsp.NET CoreSpringFlaskSpringbootSpringMVCLuaLaravelMybatisAspGroovyThinkPHPYiiswoole
文件时间pythonm相等性PHP Warning时间问题问题解决pcntl_signal采样点wav模块动态文本调用频率限制对外暴露多个访问请求更新数据表模型结构type()方法比较速度手写体sobel算子保存模型Image类nn.Conv2dpytorch1.0kaggleDCGAN交并比range()用法打印模型反卷积卷积