Ⅰ R-CNN 系列 object detection 算法
在 object detection 领域，近 5 年的突破性进展似乎都与一个名字有关系：Ross Girshick。梳理从 R-CNN，Fast R-CNN, Faster R-CNN 到 Mask R-CNN 等各种经典模型，Ross Girshick 都是作者之一，甚至连 YOLO 的作者中也出现了 Ross Girshick 的名字。
这位大神简历如下：
从算法到实现框架再到数据集，这位大神实现了一条龙的突破～
本文的目的是整理总结 R-CNN 系列算法的发展历程和模型本身的核心思想，不涉及太多技术细节（例如训练数据预处理，超参数设置等）。
参考文献主要是上述各算法的原文以及下列资源：
R-CNN，一般认为全称是 Region-based CNN 或者作者原文中提到的 Regions with CNN features。
概括地说，R-CNN 的步骤如下图所示：
下面详细介绍 R-CNN 中的关键环节。
对于输入的图片，首先利用 selective search 算法 生成约 2000 个 region。关于 selective search 算法可以参考 原文 ，也可以参考 我们之前的博客文章 。原文中提到 R-CNN 对各种 region proposal 算法没有偏好，之所以选择 selective search 算法仅仅是为了方便与前人工作做对比。
这一部分的目的是对于每一个 region，通过 CNN （原文选用 AlexNet） 进行特征提取，得到统一长度的 feature vector，以便后续的分类。
由于每个 region 的大小差别比较大，而 AlexNet 默认接收 227×227 pixel 的图片，这里就需要对 region 做一些预处理，主要是 region 大小的转化。
要把一个任意大小的图片转化成 227×227 像素的图片方法有很多，原文中介绍了 4 种方式：
分别是：
最终作者选择了 warp + padding 的方式，一方面 warp 相对来说是最简单的，直接把任意大小的图片缩放成 227×227 即可，另外 padding 是在原 region 周围稍微添加了一些像素点，从实际效果看提高了检测正确率。
将统一大小的 region 送入 CNN 中，进行特征提取。 如何得到这个 CNN 也是一个问题。
针对目标检测的数据集 ILSVRC detection dataset 包含了 200 类物体，PASCAL VOC (Visual Object Classes) 包含了 20 类物体。相对来说带有标签的训练数据比较少，不足以训练一个大型的 CNN，因此采用了 transfer learning 的技术。原文中并没有提到 transfer learning 这个名词，只是说 fine-tuning 。
首先借用在 ImageNet 上已经训练好的 CNN 模型（最初的文章中用了 AlexNet，后来 arXiv 上新版文章中用了 VGG，效果提升很明显），然后在 PASCAL 数据集上进行 fine-tuning。这里对 AlexNet 网络结构的改变只是将原本对应 ImageNet 1000 类输出的 classification layer 替换成了对应 N+1 类输出的 classification layer，该层权重随机初始化。对于 PASCAL 数据集 N=20，ILSVRC 数据集 N=200，另外 +1 对应 background 类型。
经过 fine-tuning 之后，CNN softmax layer 之前的 4096 维向量即为该 region 的 feature vector.
得到 region 的 feature vector 之后，送入 SVM 进行最后的分类。
这里 SVM 的训练是针对不同类型的物体分开进行的，每一类训练一个 SVM，它只给出针对这一类物体的分类结果。之所以最后用 SVM 分类，而不是直接用 CNN 的 softmax 进行分类，原文作者的解释是尝试过 softmax 之后发现效果比 SVM 差一些，但是同时指出如果调整一些训练策略，softmax 和 SVM 之间的差距有可能缩小。这也为后来基于 R-CNN 的改进埋下了伏笔。
得到所有 region 对应的检测结果（即包含某种类型物体的概率 score）之后，还有一步操作： Non-Maximum Suppression (NMS) 。如果两个 region 检测到同一类物体，比如都检测到了行人，一个 region score 较高，而另一个 score 较低，当这两个 region 的 IoU (intersection-over-union) 超过某个阈值时，即它们重合较多时，只保留那个 score 较高的 region.
object detection 的任务除了检测图中的物体，还要给出定位，即用 bounding box 尽量准确的圈出该物体。前边基于 region 的分类过程可能能够正确辨识出 region 中的物体，但是初始的 region 并不一定是一个合适的 bbox。在 R-CNN 最后又添加了一个线性回归模型，基于 feature vector 来预测正确的 bbox 相对于 region 的位置变换，即预测 bbox 应该如何调整。这个训练过程也是 class-specific 的。
在最终使用时，R-CNN 输出包含两部分：
理论上来说，更新 bbox 的位置之后，应该在新的 bbox 中重新进行分类，这样准确度可能更高一些，但是原文作者发现实际上并没有明显改进。因此，实际使用中并没有对新的 bbox 重新分类。
总的来说，上述 R-CNN 的训练是分多步走的：先是 fine-tuning 一个 CNN 得到 feature vector，然后训练 SVM 进行分类，最后还要再训练一个线性回归环节预测 bounding box 的调整。
Fast R-CNN 的改进是不再使用独立的 SVM 和线性回归，而是统一用 CNN 将这三个环节整合起来。Fast R-CNN 在训练时间和检测时间方面比当时已有的其他算法快若干数量级。
Fast R-CNN 整体框架如下：
基本步骤：
在上述各环节中，我认为比较关键的有两个：一是 RoI projection，即将 image 上的 RoI 映射到 feature map 上的 RoI。二是通过 RoI pooling layer 将 feature map 上不同大小的 RoI 转化成统一大小的 sub feature map。而这两个环节都借鉴了 SPPnets ，其中 RoI pooling layer 是 SPPnets 中 Spatial Pyramid Pooling layer 的特例。
原本 R-CNN 是在原图上选取若干RoI，然后经过 CNN 处理，最后提取出 feature vector。对于每个图片上不同的 RoI 来说，从输入到输出没有任何共享的东西。
RoI projection 的作用是将 R-CNN 中对 image RoI 的处理推迟到了 feature map 上，这样可以让一个 image 的所有 RoI 共享从 image 到 feature map 的卷积处理过程。这很显然会加速训练和测试过程。至于如何将 image RoI 映射到 feature map RoI，已经有了 非常细致的讨论 ，这里不再赘述。
如何将 feature map 上不同大小的 RoI 转化成统一大小的 sub feature map? 这里 有非常直观的动画演示。
概括如下：
假设我们已经得到下面的 feature map (只考虑 2D)
其中 RoI 为黑框部分，大小为 。
我们希望将 RoI 转化成 2×2 大小，可以选择一个 2×2 的窗口如下
对每一个格子进行 max pooling 操作，得到如下的 2×2 的 feature map
总的来说，如果 RoI 大小为 ，希望得到的 feature map 大小为 ，则窗口中格子数目为 。可以根据具体情况向上或向下取整。
结合实际应用，如果 CNN 网络选用 VGG16，结构如下：
将最后一个 max pooling layer 替换为 RoI pooling layer。前部的卷积层对输入图片的大小没有严格限制，这一限制主要是在 fully connected layer，所以为了配合 VGG16 网络结构，要确保每个 RoI 输出的 feature map 依然为 。
对于 VGG16 网络结构的修改还包括：
在 Fast R-CNN 中，region proposal 是由 CNN 网络之外的算法提供的，例如 selective search。相对于后续的 region recognition 过程，region proposal 这一步实际上是整个算法的速度瓶颈。
Faster R-CNN 之所以 "Faster"，就是因为提出了 Region Proposal Network (RPN) ，加速了 region proposal 过程。Faster R-CNN 本质上就是 RPN + Fast R-CNN.
整个 Faster R-CNN 结构如下：
或者更加详细的结构如下：
RPN 和 Fast R-CNN 共享从 image 到最后一层 CNN 输出的 feature map 这一段网络结构。 有些文章 也将 Faster R-CNN 看做三个模块：用于生成 feature map 的 Feature network，用于生成 region proposal 的 RPN，以及用于最终的 object detection 的 Detection network。我们这里还是采用 RPN + Fast R-CNN 的形式。
RPN 的输入是原始 image，输出是 region proposals。在具体实现中，RPN 是 fully convolutional network (FCN)，只包含 convolutional layer，原本在分类/回归中常用的全连通层也由卷积操作替代。
有了 region proposals，后边的操作与 Fast R-CNN 是相同的。
原文中采用 alternating training 的方式：
Ⅱ 经典目标检测算法介绍
姓名：牛晓银；学号：20181213993；学院：计算机科学与技术
转自：https://zhuanlan.hu.com/p/34142321
【嵌牛导读】：目标检测，也叫目标提取，是一种基于目标几何和统计特征的图像分割。随着计算机技术的发展和计算机视觉原理的广泛应用，利用计算机图像处理技术对目标进行实时跟踪研究越来越热门，对目标进行动态实时跟踪定位在智能化交通系统、军事目标检测及医学导航手术中手术器械定位等方面具有广泛的应用价值。
【嵌牛鼻子】：目标检测、检测模型、计算机视觉
【嵌牛提问】：你知道或者用过哪些目标检测算法？
【嵌牛正文】：
（一）目标检测经典工作回顾
本文结构
两阶段模型因其对图片的两阶段处理得名，也称为基于区域（Region-based）的方法，我们选取R-CNN系列工作作为这一类型的代表。
R-CNN: R-CNN系列的开山之作
论文链接： Rich feature hierarchies for accurate object detection and semantic segmentation
本文的两大贡献：1）CNN可用于基于区域的定位和分割物体；2）监督训练样本数紧缺时，在额外的数据上预训练的模型经过fine-tuning可以取得很好的效果。第一个贡献影响了之后几乎所有2-stage方法，而第二个贡献中用分类任务（Imagenet）中训练好的模型作为基网络，在检测问题上fine-tuning的做法也在之后的工作中一直沿用。
传统的计算机视觉方法常用精心设计的手工特征(如SIFT, HOG)描述图像，而深度学习的方法则倡导习得特征，从图像分类任务的经验来看，CNN网络自动习得的特征取得的效果已经超出了手工设计的特征。本篇在局部区域应用卷积网络，以发挥卷积网络学习高质量特征的能力。
R-CNN将检测抽象为两个过程，一是基于图片提出若干可能包含物体的区域（即图片的局部裁剪，被称为Region Proposal），文中使用的是Selective Search算法；二是在提出的这些区域上运行当时表现最好的分类网络（AlexNet），得到每个区域内物体的类别。
另外，文章中的两个做法值得注意。
一是数据的准备。输入CNN前，我们需要根据Ground Truth对提出的Region Proposal进行标记，这里使用的指标是IoU（Intersection over Union，交并比）。IoU计算了两个区域之交的面积跟它们之并的比，描述了两个区域的重合程度。
文章中特别提到，IoU阈值的选择对结果影响显着，这里要谈两个threshold，一个用来识别正样本（如跟ground truth的IoU大于0.5），另一个用来标记负样本（即背景类，如IoU小于0.1），而介于两者之间的则为难例（Hard Negatives），若标为正类，则包含了过多的背景信息，反之又包含了要检测物体的特征，因而这些Proposal便被忽略掉。
另一点是位置坐标的回归（Bounding-Box Regression），这一过程是Region Proposal向Ground Truth调整，实现时加入了log/exp变换来使损失保持在合理的量级上，可以看做一种标准化（Normalization)操作。
小结
R-CNN的想法直接明了，即将检测任务转化为区域上的分类任务，是深度学习方法在检测任务上的试水。模型本身存在的问题也很多，如需要训练三个不同的模型（proposal, classification, regression）、重复计算过多导致的性能问题等。尽管如此，这篇论文的很多做法仍然广泛地影响着检测任务上的深度模型革命，后续的很多工作也都是针对改进这一工作而展开，此篇可以称得上"The First Paper"。
Fast R-CNN: 共享卷积运算
论文链接： Fast R-CNN
文章指出R-CNN耗时的原因是CNN是在每一个Proposal上单独进行的，没有共享计算，便提出将基础网络在图片整体上运行完毕后，再传入R-CNN子网络，共享了大部分计算，故有Fast之名。
上图是Fast R-CNN的架构。图片经过feature extractor得到feature map, 同时在原图上运行Selective Search算法并将RoI（Region of Interset，实为坐标组，可与Region Proposal混用）映射到到feature map上，再对每个RoI进行RoI Pooling操作便得到等长的feature vector，将这些得到的feature vector进行正负样本的整理（保持一定的正负样本比例），分batch传入并行的R-CNN子网络，同时进行分类和回归，并将两者的损失统一起来。
RoI Pooling 是对输入R-CNN子网络的数据进行准备的关键操作。我们得到的区域常常有不同的大小，在映射到feature map上之后，会得到不同大小的特征张量。RoI Pooling先将RoI等分成目标个数的网格，再在每个网格上进行max pooling，就得到等长的RoI feature vector。
文章最后的讨论也有一定的借鉴意义：
multi-loss traing相比单独训练classification确有提升
multi-scale相比single-scale精度略有提升，但带来的时间开销更大。一定程度上说明CNN结构可以内在地学习尺度不变性
在更多的数据(VOC)上训练后，精度是有进一步提升的
Softmax分类器比"one vs rest"型的SVM表现略好，引入了类间的竞争
更多的Proposal并不一定带来精度的提升
小结
Fast R-CNN的这一结构正是检测任务主流2-stage方法所采用的元结构的雏形。文章将Proposal, Feature Extractor, Object Classification&Localization统一在一个整体的结构中，并通过共享卷积计算提高特征利用效率，是最有贡献的地方。
Faster R-CNN: 两阶段模型的深度化
论文链接： Faster R-CNN: Towards Real Time Object Detection with Region Proposal Networks
Faster R-CNN是2-stage方法的奠基性工作，提出的RPN网络取代Selective Search算法使得检测任务可以由神经网络端到端地完成。粗略的讲，Faster R-CNN = RPN + Fast R-CNN，跟RCNN共享卷积计算的特性使得RPN引入的计算量很小，使得Faster R-CNN可以在单个GPU上以5fps的速度运行，而在精度方面达到SOTA（State of the Art，当前最佳）。
本文的主要贡献是提出Regional Proposal Networks，替代之前的SS算法。RPN网络将Proposal这一任务建模为二分类（是否为物体）的问题。
第一步是在一个滑动窗口上生成不同大小和长宽比例的anchor box（如上图右边部分），取定IoU的阈值，按Ground Truth标定这些anchor box的正负。于是，传入RPN网络的样本数据被整理为anchor box（坐标）和每个anchor box是否有物体（二分类标签）。RPN网络将每个样本映射为一个概率值和四个坐标值，概率值反应这个anchor box有物体的概率，四个坐标值用于回归定义物体的位置。最后将二分类和坐标回归的损失统一起来，作为RPN网络的目标训练。
由RPN得到Region Proposal在根据概率值筛选后经过类似的标记过程，被传入R-CNN子网络，进行多分类和坐标回归，同样用多任务损失将二者的损失联合。
小结
Faster R-CNN的成功之处在于用RPN网络完成了检测任务的"深度化"。使用滑动窗口生成anchor box的思想也在后来的工作中越来越多地被采用（YOLO v2等）。这项工作奠定了"RPN+RCNN"的两阶段方法元结构，影响了大部分后续工作。
单阶段（1-stage）检测模型
单阶段模型没有中间的区域检出过程，直接从图片获得预测结果，也被成为Region-free方法。
YOLO
论文链接： You Only Look Once: Unified, Real-Time Object Detection
YOLO是单阶段方法的开山之作。它将检测任务表述成一个统一的、端到端的回归问题，并且以只处理一次图片同时得到位置和分类而得名。
YOLO的主要优点：
快。
全局处理使得背景错误相对少，相比基于局部（区域）的方法， 如Fast RCNN。
泛化性能好，在艺术作品上做检测时，YOLO表现比Fast R-CNN好。
YOLO的工作流程如下：
1.准备数据：将图片缩放，划分为等分的网格，每个网格按跟Ground Truth的IoU分配到所要预测的样本。
2.卷积网络：由GoogLeNet更改而来，每个网格对每个类别预测一个条件概率值，并在网格基础上生成B个box，每个box预测五个回归值，四个表征位置，第五个表征这个box含有物体（注意不是某一类物体）的概率和位置的准确程度（由IoU表示）。测试时，分数如下计算：
等式左边第一项由网格预测，后两项由每个box预测，以条件概率的方式得到每个box含有不同类别物体的分数。 因而，卷积网络共输出的预测值个数为S×S×(B×5+C)，其中S为网格数，B为每个网格生成box个数，C为类别数。
3.后处理：使用NMS（Non-Maximum Suppression，非极大抑制）过滤得到最后的预测框
损失函数的设计
损失函数被分为三部分：坐标误差、物体误差、类别误差。为了平衡类别不均衡和大小物体等带来的影响，损失函数中添加了权重并将长宽取根号。
小结
YOLO提出了单阶段的新思路，相比两阶段方法，其速度优势明显，实时的特性令人印象深刻。但YOLO本身也存在一些问题，如划分网格较为粗糙，每个网格生成的box个数等限制了对小尺度物体和相近物体的检测。
SSD: Single Shot Multibox Detector
论文链接： SSD: Single Shot Multibox Detector
SSD相比YOLO有以下突出的特点：
多尺度的feature map：基于VGG的不同卷积段，输出feature map到回归器中。这一点试图提升小物体的检测精度。
更多的anchor box，每个网格点生成不同大小和长宽比例的box，并将类别预测概率基于box预测（YOLO是在网格上），得到的输出值个数为(C+4)×k×m×n，其中C为类别数，k为box个数，m×n为feature map的大小。
小结
SSD是单阶段模型早期的集大成者，达到跟接近两阶段模型精度的同时，拥有比两阶段模型快一个数量级的速度。后续的单阶段模型工作大多基于SSD改进展开。
检测模型基本特点
最后，我们对检测模型的基本特征做一个简单的归纳。
检测模型整体上由基础网络（Backbone Network）和检测头部（Detection Head）构成。前者作为特征提取器，给出图像不同大小、不同抽象层次的表示；后者则依据这些表示和监督信息学习类别和位置关联。检测头部负责的类别预测和位置回归两个任务常常是并行进行的，构成多任务的损失进行联合训练。
相比单阶段，两阶段检测模型通常含有一个串行的头部结构，即完成前背景分类和回归后，把中间结果作为RCNN头部的输入再进行一次多分类和位置回归。这种设计带来了一些优点：
对检测任务的解构，先进行前背景的分类，再进行物体的分类，这种解构使得监督信息在不同阶段对网络参数的学习进行指导
RPN网络为RCNN网络提供良好的先验，并有机会整理样本的比例，减轻RCNN网络的学习负担
这种设计的缺点也很明显：中间结果常常带来空间开销，而串行的方式也使得推断速度无法跟单阶段相比；级联的位置回归则会导致RCNN部分的重复计算（如两个RoI有重叠）。
另一方面，单阶段模型只有一次类别预测和位置回归，卷积运算的共享程度更高，拥有更快的速度和更小的内存占用。读者将会在接下来的文章中看到，两种类型的模型也在互相吸收彼此的优点，这也使得两者的界限更为模糊。
Ⅲ 计算机图形学， 光线跟踪算法的过程是什么
光线跟踪思路：从视点出发，通过图像平面上每个像素中心向场景发出一条光线，光线的起点为视点，方向为像素中心和视点连线单位向量。光线与离视点最近的场景物体表面交点有三种可能：
当前交点所在的物体表面为理想漫射面，跟踪结束。
当前交点所在的物体表面为理想镜面，光线沿其镜面发射方向继续跟踪。
当前交点所在的物体表面为规则透射面，光线沿其规则透射方向继续跟踪。
伪代码：
void TraceRay(const Vec3& start, const Vec3& direction, int depth, Color& color)
{
Vec3 intersectionPoint, reflectedDirection, transmittedDirection;
Color localColor, reflectedColor, transmittedColor;
if (depth >= MAX_DEPTH) {
color = Black; //#000
}
else {
Ray ray(start, direction); //取start起点，方向direction为跟踪射线；
if ( !scene->HasIntersection(ray) )
color = BackgroundColor;
else {
计算理起始点start最近的交点intersectionPoint,
记录相交物体intersectionObject,
// #1
Shade(intersectionObject, intersectionPoint, localColor);
// #2
if ( intersectionPoint所在面为镜面 ) {
计算跟踪光想S在intersectionPoint处的反射光线方向reflectedDirection,
TraceRay(intersectionPoint, reflectedDirection, depth+1, reflectedColor);
}
// #3
if ( intersectionPoint所在的表面为透明面 ) {
计算跟踪光线S在intersectionPoint处的规则透射光线方向transmittedDirection,
TraceRay(intersectionPoint, transmittedDirection, depth+1, transmittedColor);
}
// #summarize
color = localColor + Ks * reflectedColor + Kt * transmittedColor;
}// else
} //else
}
// 局部光照模型计算交点intersectionPoint处的局部光亮度localColor
void Shade(const Object& intersectionObj, const Vec3& intersectionPoint, Color& localColor)
{
确定intersectionObj在intersectionPoint处的单位法向量N,
漫反射系数Kd,
镜面反射系数Ks,
环境反射系数Ka;
localColor = Ka * Ia; //Ia为环境光亮度
for ( 每一个点光源PointLight ) {
计算入射光线单位向量L和虚拟镜面法向单位向量H,
// 由Phong模型计算光源PointLight在intersectionPoint处的漫反射和镜面反射光亮度
localColor += ( Ipointlight * ( Kd * (N.dot(L)) + Ks * (N.dot(H))^n ) );
}
}
Ⅳ java 椭圆算法
以下代码，将输出一个椭圆，再有问题，我可远程助你。如下：
/**
*(300,100)(400,100)
*
*/
importjava.awt.*;
importjavax.swing.*;
importjava.awt.event.*;
publicclassLipse
{
publicstaticvoidmain(String[]args)
{
newMainFrame();
}
}
{
JPanelpane=newJPanel();
JTextFieldT_a,T_b;
JButtonDraw,Show;
JLabelL_a,L_b;
inta,b;
MainFrame()
{
super("DrawLipseWindow");
Containercon=this.getContentPane();
con.setLayout(null);
pane.setBounds(20,20,850,550);
pane.setBackground(newColor(100,156,200));
con.add(pane);
L_a=newJLabel("请输入长半径:a");
L_a.setBounds(180,580,100,20);
con.add(L_a);
L_b=newJLabel("请输入短半径:b");
L_b.setBounds(180,630,100,20);
con.add(L_b);
T_a=newJTextField();
T_a.setBounds(300,580,50,20);
con.add(T_a);
T_b=newJTextField();
T_b.setBounds(300,630,50,20);
con.add(T_b);
Draw=newJButton("画椭圆");
Draw.setBounds(550,580,90,30);
Draw.addActionListener(this);
con.add(Draw);
Show=newJButton("显示坐标");
Show.setBounds(550,620,90,30);
Show.addActionListener(this);
con.add(Show);
this.addWindowListener(newCloseWindow());
this.setBounds(20,20,900,700);
this.setVisible(true);
this.setResizable(false);
}/*MainFrame()*/
publicvoidactionPerformed(ActionEvente)
{
if(e.getSource()==Draw)
{
a=Integer.parseInt(T_a.getText().trim());
b=Integer.parseInt(T_b.getText().trim());
Lineline=newLine(this);
line.drawLipse(a,b);
}
if(e.getSource()==Show)
{
Graphicsg1=this.pane.getGraphics();
g1.setColor(Color.PINK);
g1.drawLine(0,300,920,300);//----x---
g1.drawLine(410,0,410,720);//----y---
g1.dispose();
}
}/*methodactionPerformed*/
}
classLine
{
MainFramejb;
Line(MainFramejb)
{
this.jb=jb;
}
publicvoiddrawLipse(inta,intb)
{
intx,y;
doubled1,d2;
x=0;y=b;
d1=b*b+a*a*(-b+0.25);
Graphicsg=jb.pane.getGraphics();
g.setColor(Color.red);
g.drawLine(x+410,y+300,x+410,y+300);
g.drawLine(-x+410,-y+300,-x+410,-y+300);
g.drawLine(-x+410,y+300,x+410,-y+300);
g.drawLine(x+410,-y+300,x+410,-y+300);
try
{
while(b*b*(x+1)<a*a*(y-0.5))
{
if(d1<=0)
{
d1+=b*b*(2*x+3);
x++;
}
else
{
d1+=(b*b*(2*x+3)+a*a*(-2*y+2));
x++;
y--;
}
g.drawLine(x+410,y+300,x+410,y+300);
g.drawLine(-x+410,-y+300,-x+410,-y+300);
g.drawLine(-x+410,y+300,x+410,-y+300);
g.drawLine(x+410,-y+300,x+410,-y+300);
Thread.sleep(30);
}//topofwhile
}catch(Exceptione){}
d2=b*b*(x+0.5)*(x+0.5)+a*a*(y-1)*(y-1)-a*a*b*b;
try
{
while(y>0)
{
if(d2<=0)
{
d2+=b*b*(2*x+2)+a*a*(-2*y+3);
x++;
y--;
}
else
{
d2+=a*a*(-2*y+3);
y--;
}
g.drawLine(x+410,y+300,x+410,y+300);
g.drawLine(-x+410,-y+300,-x+410,-y+300);
g.drawLine(-x+410,y+300,x+410,-y+300);
g.drawLine(x+410,-y+300,x+410,-y+300);
Thread.sleep(30);
}/*bottomofwhile*/
}catch(Exceptione){}
}/*DrawLipse*/
}
{
publicvoidwindowClosing(WindowEvente)
{
System.exit(0);
}
}