Nicholl-Lee-Nicholl算法裁剪线段

最新推荐文章于 2023-11-28 20:36:49 发布
最新推荐文章于 2023-11-28 20:36:49 发布
阅读量1.1k 收藏 14
点赞数 3
分类专栏： 计算机图形学 文章标签： Nicholl-Lee-Nicholl的算法 裁剪线段 计算机图形学 pyqt5 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42185999/article/details/102672534
版权

算法简介：

 

Nicholl-Lee-Nicholl（NLN）算法通过在裁剪窗口边界创建多个区域，从而避免对一个直线段进行多次裁剪。

Cohen-Sutherland算法中，在找到与裁剪窗口边界的交点之前或完全舍弃该线段之前，必须对一条线段进行多次求交计算。NLN算法则在求交计算前进行更多的区域测试，从而减少求交计算。

NLN算法的特点是效率高，但该算法仅用于二维裁剪。

 


算法描述：

 

如上图，对于 b 这种完全在矩形内的线段，和 a 这种两端点都在矩形同一侧的线段，可以直接采用Cohen-Sutherland编码方法进行取舍（不熟的朋友请参看文章：Cohen-Sutherland算法 ---- https://blog.csdn.net/qq_42185999/article/details/102668328）。

对于 d 这种不能采用上述方法直接判断的线段，还有 c 这种既不是完全可见也不是完全不可见的线段，Nicholl-Lee-Nicholl算法处理步骤如下：

 

第一步：

对于端点为 P0 和 P1 的线段，首先确定P0位于裁剪窗口的九个可能区域的位置。如下图，我们只需考虑四个区域。若位于其他五个区域之一，则可以利用对称变换将其变换到这四个区域之一。

 

                                

 

第二步：

从 P0 点向窗口的四个角点发出射线，这四条射线和窗口的四条边所在的直线将二维平面划分为更多的小区域。此时 P1 的位置就决定了 P0P1 和窗口边的相交关系。

 

第三步：

确定 P1 所在的区域（判断 P1 所在区域位置，可判断 P0P1 与窗口那条边求交），根据窗口四边的坐标值及 P0P1 和各射线的斜率可确定 P1 所在的区域。

 

第四步：求交点，确定 P0P1 的可见部分

 

 

如上图，当 P0 在框内：

如果 P1 位于 L 区，则只需求 P0P1 与 窗口左边的交点 P_{1}^{}{}'   ,   P_{0}{P_{1}}' 即为所取线段； 

如果 P1 位于 T 区，则只需求 P0P1 与 窗口上边的交点 P_{1}^{}{}'   ,   P_{0}{P_{1}}' 即为所取线段 ； 

如果 P1 位于 R 区，则只需求 P0P1 与 窗口右边的交点 P_{1}^{}{}'   ,   P_{0}{P_{1}}' 即为所取线段 ； 

如果 P1 位于 B 区，则只需求 P0P1 与 窗口底边的交点 P_{1}^{}{}'   ,   P_{0}{P_{1}}' 即为所取线段。

 

如上图，当 P0 在框上侧：

如果 P1 位于 T 区，则只需求 P0P1 与 窗口上边的交点 P_{0}^{}{}'   ,   {P_{0}}'P_{1} 即为所取线段；

如果 P1 位于 LT 区，则需求 P0P1 与 窗口上边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口左边的交点 P_{1}^{}{}' ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

如果 P1 位于 BT 区，则需求 P0P1 与 窗口上边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口底边的交点 P_{1}^{}{}' ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

如果 P1 位于 TR 区，则需求 P0P1 与 窗口上边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口右边的交点 P_{1}^{}{}' ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

 

 

如上图，当 P0 在框左侧：

如果 P1 位于 L 区，则只需求 P0P1 与 窗口左边的交点 P_{0}^{}{}'   ,   {P_{0}}'P_{1} 即为所取线段；

如果 P1 位于 LT 区，则需求 P0P1 与 窗口左边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口上边的交点 P_{1}^{}{}' ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

如果 P1 位于 LR 区，则需求 P0P1 与 窗口左边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口右边的交点 P_{1}^{}{}'​​​​​​​ ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

如果 P1 位于 LB 区，则需求 P0P1 与 窗口左边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口底边的交点 P_{1}^{}{}'​​​​​​​ ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

 

 

 

当P0在窗口的左上方时，有如下图的两种情况：

 

（a） .   P0接近裁剪窗口左边界

如果 P1 位于 L 区，则只需求 P0P1 与 窗口左边的交点 P_{0}^{}{}'   ,   {P_{0}}'P_{1} 即为所取线段；

如果 P1 位于 T 区，则只需求 P0P1 与 窗口上边的交点 P_{0}^{}{}'   ,   {P_{0}}'P_{1} 即为所取线段；

如果 P1 位于 LB 区，则需求 P0P1 与 窗口左边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口底边的交点 P_{1}^{}{}'​​​​​​​ ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

如果 P1 位于 TB 区，则需求 P0P1 与 窗口上边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口底边的交点 P_{1}^{}{}'​​​​​​​ ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

如果 P1 位于 TR 区，则需求 P0P1 与 窗口上边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口右边的交点 P_{1}^{}{}'​​​​​​​ ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

 

 

（b） .   P0接近裁剪窗口上边界

如果 P1 位于 L 区，则只需求 P0P1 与 窗口左边的交点 P_{0}^{}{}'   ,   {P_{0}}'P_{1} 即为所取线段；

如果 P1 位于 T 区，则只需求 P0P1 与 窗口上边的交点 P_{0}^{}{}'   ,   {P_{0}}'P_{1} 即为所取线段；

如果 P1 位于 LB 区，则需求 P0P1 与 窗口左边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口底边的交点 P_{1}^{}{}'​​​​​​​ ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

如果 P1 位于 LR 区，则需求 P0P1 与 窗口左边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口右边的交点 P_{1}^{}{}'​​​​​​​ ，   {P_{0}}'{P_{1}}' 即为所取线段 ； 

如果 P1 位于 TR 区，则需求 P0P1 与 窗口上边的交点 P_{0}^{}{}'   ,  P0P1 与 窗口右边的交点 P_{1}^{}{}'​​​​​​​ ，   {P_{0}}'{P_{1}}' 即为所取线段 ；

 

 

 

算法的细节：

 

判断 P1 具体所在区域：

首先，根据 P0P1 和各射线的斜率可确定 P1 所在的大概区域。然后，根据线段端点 P1 的编码判断 P1 是否在窗口内，进一步判断 P1 所在具体区域。

 

直线与窗口边界的交点可如下求解：

已知直线和其两端点 (X_{1},Y_{1}) ， (X_{2},Y_{2}) ， 与水平线 Y=K 的交点为 （X,Y）

X=X_{1}+(X_{2}-X_{1})*(K-Y_{1})/(Y_{2}-Y_{1})     

Y=K

与铅垂线 X=R 的交点为

X=R

Y=Y_{1}+(Y_{2}-Y_{1})*(R-X_{1})/(X_{2}-X_{1})     

   

 

核心代码：

（这里贴代码是给大家看看思路，这个代码运行出来有一点问题，坐标转换不对，但是我没检查出来问题，还请各位大佬帮忙看看，谢谢啦！）

    def line_clip(self, line1, rt):
        done = False  # 裁剪完成标志
        p1 = line1.p1()
        print(p1);
        p2 = line1.p2()
        print(p2);
        c1 = self.getcode(p1, rt)
        c2 = self.getcode(p2, rt)
        p = QPoint(0, 0)
        line2 = QLine(p, p)
        biaozhi = True


        if c1 == 0 and c2 == 0:  # 线段完全可见
            line2 = QLine(p1, p2)
        elif c1 & c2 != 0:  # 线段完全不可见
            line2 = QLine(QPoint(0, 0), QPoint(0, 0))
        else:  # 部分可见
            if(c1 == 0x02): #右侧变换
                print("右侧变换");
                p1.setX(2*rt.x()+rt.width()-p1.x())
                p2.setX(2 * rt.x() + rt.width() - p2.x())
            if (c1 == 0x0a):  # 右上侧变换
                print("右上侧变换");
                p1.setX(2 * rt.x() + rt.width() - p1.x())
                p2.setX(2 * rt.x() + rt.width() - p2.x())
            if (c1 == 0x05):  # 左下侧变换
                print("左下侧变换");
                p1.setY(2 * rt.y() + rt.height() - p1.y())
                p2.setY(2 * rt.y() + rt.height() - p2.y())
            if (c1 == 0x06):  # 右下侧变换
                print("右下侧变换");
                p1.setX(2 * rt.x() + rt.width() - p1.x())
                p2.setX(2 * rt.x() + rt.width() - p2.x())
                p1.setY(2 * rt.y() + rt.height() - p1.y())
                p2.setY(2 * rt.y() + rt.height() - p2.y())
            if (c1 == 0x04):  # 下侧变换
                print("下侧变换");
                p1.setY(2 * rt.y() + rt.height() - p1.y())
                p2.setY(2 * rt.y() + rt.height() - p2.y())

            c11 = self.getcode(p1, rt)
            c22 = self.getcode(p2, rt)

            mLT = (p1.y()-rt.top())/(p1.x()-rt.left())
            mTR = (p1.y()-rt.top())/(p1.x()-rt.right())
            mBL = (p1.y() - rt.bottom()) / (p1.x() - rt.left())
            mRB = (p1.y() - rt.bottom()) / (p1.x() - rt.right())
            m = (p1.y()-p2.y())/(p1.x()-p2.x())

            ##   判断起点位置
            if(c11 == 0x00): # 情况一：在框内
                print("在框内");
                # left
                if(m < mBL and m >= mLT):
                    print("L");
                    p2.setX(rt.left())
                    p2.setY(p1.y()+(p2.y()-p1.y())*(rt.left()-p1.x())/(p2.x()-p1.x()))
                #bottom
                if(m >= mBL or m < mRB):
                    print("b");
                    p2.setY(rt.bottom())
                    p2.setX(p1.x()+(p2.x()-p1.x())*(rt.bottom()-p1.y())/(p2.y()-p1.y()))
                #right
                if(m >= mRB and m < mTR):
                    print("r");
                    p2.setX(rt.right())
                    p2.setY(p1.y() + (p2.y() - p1.y()) * (rt.right() - p1.x()) / (p2.x() - p1.x()))
                #top
                if(m >= mTR or m < mLT):
                    print("t");
                    p2.setY(rt.top())
                    p2.setX(p1.x() + (p2.x() - p1.x()) * (rt.top() - p1.y()) / (p2.y() - p1.y()))


            elif (c11 == 0x01):  # 情况二：在框左侧
                print("在框左侧");
                if(m < mBL or m >= mLT):
                    print("diudiao");
                    biaohzi = False
                    #line2 = QLine(QPoint(0, 0), QPoint(0, 0))
                else:
                    #起点剪裁
                    biaohzi = True
                    p1.setX(rt.left())
                    p1.setY(p2.y() + (p1.y() - p2.y()) * (rt.left() - p2.x()) / (p1.x() - p2.x()))
                    if(c22 != 0x00):
                        if(mBL <= m and m < mRB): #LB
                            p2.setY(rt.bottom())
                            p2.setX(p1.x() + (p2.x() - p1.x()) * (rt.bottom() - p1.y()) / (p2.y() - p1.y()))
                        elif(mRB <= m and m < mTR): #LR
                            p2.setX(rt.right())
                            p2.setY(p1.y() + (p2.y() - p1.y()) * (rt.right() - p1.x()) / (p2.x() - p1.x()))
                        elif(mTR <= m and m < mLT): #LT
                            p2.setY(rt.top())
                            p2.setX(p1.x() + (p2.x() - p1.x()) * (rt.top() - p1.y()) / (p2.y() - p1.y()))


            elif (c11 == 0x09):  # 情况三：在框左上侧
                print("在框左上侧");
                if(m < mBL or m >= mTR): #区域外
                    biaozhi = False
                else:
                    biaohzi = True
                    # 起点靠近左裁剪线
                    if((rt.left()-p1.x()) < (p1.y()-rt.top())):
                        if(mBL <= m and m < mLT):  #L
                            p1.setX(rt.left())
                            p1.setY(p2.y() + (p1.y() - p2.y()) * (rt.left() - p2.x()) / (p1.x() - p2.x()))
                            if(c22 != 0x00):   # LB
                                p1.setY(rt.bottom())
                                p1.setX(p2.x() + (p1.x() - p2.x()) * (rt.bottom() - p2.y()) / (p1.y() - p2.y()))
                        elif(mLT <= m and m < mRB):
                            p1.setY(rt.top())
                            p1.setX(p2.x() + (p1.x() - p2.x()) * (rt.top() - p2.y()) / (p1.y() - p2.y()))
                            if(c22 != 0x00): # TB
                                p2.setY(rt.bottom())
                                p2.setX(p1.x() + (p2.x() - p1.x()) * (rt.bottom() - p1.y()) / (p2.y() - p1.y()))

                        elif(mRB <= m and m < mTR):
                            p1.setY(rt.top())
                            p1.setX(p2.x() + (p1.x() - p2.x()) * (rt.top() - p2.y()) / (p1.y() - p2.y()))
                            if (c22 != 0x00): # TR
                                p2.setX(rt.right())
                                p2.setY(p1.y() + (p2.y() - p1.y()) * (rt.right() - p1.x()) / (p2.x() - p1.x()))

                    # 起点靠近上裁剪线
                    else:
                        if(mBL <= m and m < mRB): # L
                            p1.setX(rt.left())
                            p1.setY(p2.y() + (p1.y() - p2.y()) * (rt.left() - p2.x()) / (p1.x() - p2.x()))
                            if(c22 != 0x00):  # LB
                                p2.setY(rt.bottom())
                                p2.setX(p1.x() + (p2.x() - p1.x()) * (rt.bottom() - p1.y()) / (p2.y() - p1.y()))

                        elif(mRB <= m and m < mLT): # L
                            p1.setX(rt.left())
                            p1.setY(p2.y() + (p1.y() - p2.y()) * (rt.left() - p2.x()) / (p1.x() - p2.x()))
                            if(c22 != 0x00):  # LR
                                p2.setX(rt.right())
                                p2.setY(p1.y() + (p2.y() - p1.y()) * (rt.right() - p1.x()) / (p2.x() - p1.x()))

                        elif(mLT <= m and m < mTR): # T
                            p1.setY(rt.top())
                            p1.setX(p2.x() + (p1.x() - p2.x()) * (rt.top() - p2.y()) / (p1.y() - p2.y()))
                            if(c22 != 0x00):  #TR
                                p2.setX(rt.right())
                                p2.setY(p1.y() + (p2.y() - p1.y()) * (rt.right() - p1.x()) / (p2.x() - p1.x()))



            elif (c11 == 0x08): # 情况四：在框上侧
                print("在框上侧");

                if((m > 0 and m < mLT) or (m < 0 and m >= mTR)):
                    biaozhi = False
                    #line2 = QLine(QPoint(0, 0), QPoint(0, 0))
                else:
                    # T
                    p1.setY(rt.top())
                    p1.setX(p2.x() + (p1.x() - p2.x()) * (rt.top() - p2.y()) / (p1.y() - p2.y()))
                    if(c22 != 0x00):
                        if(mLT <= m and m < mBL): #TL
                            p2.setX(rt.left())
                            p2.setY(p1.y() + (p2.y() - p1.y()) * (rt.left() - p1.x()) / (p2.x() - p1.x()))
                        elif(m >= mBL or m <= mRB): # TB
                            p2.setY(rt.bottom())
                            p2.setX(p1.x() + (p2.x() - p1.x()) * (rt.bottom() - p1.y()) / (p2.y() - p1.y()))
                        elif(mRB <= m and m < mTR): # TR
                            p2.setX(rt.right())
                            p2.setY(p1.y() + (p2.y() - p1.y()) * (rt.right() - p1.x()) / (p2.x() - p1.x()))



            #恢复对称区域的变化
            if (c1 == 0x02):  # 右侧变换
                print("hui右侧变换");
                p1.setX(2 * rt.x() + rt.width() - p1.x())
                p2.setX(2 * rt.x() + rt.width() - p2.x())
            if (c1 == 0x0a):  # 右上侧变换
                print("hui右上侧变换");
                p1.setX(2 * rt.x() + rt.width() - p1.x())
                p2.setX(2 * rt.x() + rt.width() - p2.x())
            if (c1 == 0x05):  # 左下侧变换
                print("下侧变换");
                p1.setY(2 * rt.y() + rt.height() - p1.y())
                p2.setY(2 * rt.y() + rt.height() - p2.y())
            if (c1 == 0x06):  # 右下侧变换
                print("下侧变换");
                p1.setX(2 * rt.x() + rt.width() - p1.x())
                p2.setX(2 * rt.x() + rt.width() - p2.x())
                p1.setY(2 * rt.y() + rt.height() - p1.y())
                p2.setY(2 * rt.y() + rt.height() - p2.y())
            if (c1 == 0x04):  # 下侧变换
                print("下侧变换");
                p1.setY(2 * rt.y() + rt.height() - p1.y())
                p2.setY(2 * rt.y() + rt.height() - p2.y())



            if(biaozhi == False):
                line2 = QLine(QPoint(0, 0), QPoint(0, 0))
            else:
                line2 = QLine(p1, p2)


        return line2

 

 

 

PS: 这里是完整代码，欢迎移步：https://pan.baidu.com/s/13Gu5JtZ5DRJIw35_aRPyHQ  进行下载

想去的远方
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Nicholl-Lee-Nicholl
05-03
Nicholl-Lee-Nicholl
计算机图形学 线段剪裁NLN算法
05-09
NLN算法（Nicholl-Lee-Nicholl Algorithm）是这种剪裁方法的一种，它针对直线段的裁剪问题提供了一种高效的解决方案。 线段剪裁的基本思想是通过判断线段的端点与裁剪窗口的关系来确定线段的可见部分。在Cohen-...
计算机图形学 学习笔记 二维观察
漫漫无期的博客
10-05 3170
二维观察流水线 二维场景中要显示的部分称为裁剪窗口，所有在此区域之外的场景均要裁去。只有在裁剪窗口内部的场景才能显示在屏幕上。裁剪窗口有时暗指世界窗口或观察窗口。使用术语裁剪窗口来表示可能转换为监视器上某显示窗口的点阵的场景部分。图形系统还用称为视口的另一“窗口”来控制在显示窗口的定位。对象在裁剪窗口内的部分映射到显示窗口中指定位置的视口中。窗口选择要看什么，而视口指定在输出设备的什么位置进行观察。 通过改变视口的位置，可以在输出设备显示区域的不同位置观察物体。 场景的描述从二维世界坐标系到设备坐标系
Nicholl-Lee-Nicholl线段裁剪算法
weixin_44348327的博客
05-12 1198
Nicholl-Lee-Nicholl线段裁剪算法学习与详解 【算法简介】 Nicholl-Lee-Nicholl（NLN）算法通过在裁剪窗口边界创建多个区域，从而避免对一个直线段进行多次裁剪。 Cohen-Sutherland算法中，在找到与裁剪窗口边界的交点之前或完全舍弃该线段之前，必须对一条线段进行多次求交计算。NLN算法则在求交计算前进行更多的区域测试，从而减少求交计算。 与Cohen-S...
计算机图形学实验五-直线段的编码裁剪算法（Cohen-SutherLand算法）
weixin_53249260的博客
08-21 2064
连接和裁剪区域的4个角点的直线分别记为LT、RT、LB、RB，通过比较P0P1和这四条直线的斜率，可以确定直线的可见性、直线与区域边界的交点个数及交点所在边界。：参考Cohen-SutherLand算法的编码形式，定义编码函数，得到传入的点的坐标，首先判断是否完全可见，完全可见则直接绘制，完全不可见则直接抛弃，以上两种情况均不符合则为部分可见的情况，则开始判断起点所处的区域，针对三个不同的区域进行不同区域的处理，根据不同的斜率值进行不同交点的求解，这里就体现了NLN直线段裁剪算法的。
计算机图形学实验之直线段的编码裁剪算法（Cohen-SutherLand算法
最新发布
xp1683464115的博客
11-28 418
库来创建窗口，并绘制了一个矩形框和一个经过裁剪的直线段。（可选）： 实现NLN直线段裁剪算法。： 掌握相关算法的原理及实现。,可以修改坐标来进行其他测试。
图形学算法之Nicholl-Lee-Nicholl算法
weixin_30693183的博客
06-20 437
在本学期的所学的裁剪算法中，有一个叫做Nicholl-Lee-Nicholl的算法。 在实践中，我遇到了一个小问题，因为教程中所讲的只有起点在剪裁框内、左侧和左上的情况，并说其余情况均可以通过点的平移或旋转变换等方式变换到上述3个区域内。 但考虑到裁剪框并不都是正方形，所以上方区域和左侧区域也不都是完全映射的，所以并不能简单的旋转平移点，而是整个屏幕都旋转，这样的话还不如为上方区域单独做算法。...
二维观察---二维线段裁剪
weixin_34126215的博客
11-05 314
为什么80%的码农都做不了架构师？>>> ...
chasenicholl:Chase Nicholl——技术负责人、软件工程师、企业家、大思想家、音乐家
05-30
【chasenicholl:Chase Nicholl——技术负责人、软件工程师、企业家、大思想家、音乐家】 在当今数字化的世界中，多才多艺的人才备受瞩目，Chase Nicholl就是这样一位融合了多种角色的人物。他是一位技术负责人，这...
《计算机图形学的算法基础 》(David F.Rogers)原书第2版 石教英 彭群生 译
04-14
新版本增加了图形用户界面、椭圆、图像压缩和线条反走样算法等，还增加了Liang-Barsky裁剪算法和Nicholl-Lee-Nicholl裁剪算法。新版本大大扩充了可见面光线跟踪算法。在绘制这一章中新增了基于物理的光照明模型，...
nicholl-lee-nicholl的标准实现
jcyangzh的专栏
06-23 1185
<br />参照nicholl-lee-nicholl的原始论文而成,版权归nicholl-lee-nicholl所有.<br />void leftcolumn(float*, float*, float*, float*, float, float, float, float, bool*); void centercolumn(float*, float*, float*, float*, float, float, float, float, bool*); void topleftcorner
算法复杂度O(nlogn)详解
热门推荐
shikelang_pp的博客
08-13 2万+
首先看以下程序段： for（int i=1;i {           for(int j=1;j            {                    .....   //复杂度为O(1);             } } 求该程序段的时间复杂度。 可以看出：（1）当i=1时，需要执行n次；                      （2）当i=2时，需要执行n/2
计算机图形学，DDA，Bresenangham,填充区域边表，有效边表，cohen-Sutherand,Liang-Barsky,NLN,Sutherland-Hodgeman算法
玖歌的博客
06-03 2808
一 DDA算法    (一） 原理：DDA算法跟在坐标系中画直线类似函数y=0.5*x+1x123456y1.522.5   33.54在坐标系中描绘这六个点，用线连接起来，就是函数的直线    DDA算法简单来说寻找合适的进度（例如，x方向，从起点x=1到x=6，x_length=5），求得其步长（x_step=(6-1)/x_length=1,y_step=(4-1)/x_length=0.6...
NLN中的MLP操作
weixin_30826095的博客
01-22 149
MLP操作：# 前面是正常的卷积操作 # 这里是mlp conv, 可以看出就是一个1*1的卷积操作(等价于全连接操作) layers { bottom: "conv1" top: "cccp1" name: "cccp1" type: CONVOLUTION blobs_lr: 1 blobs_lr: 2 weight_decay: 1 weight_decay: 0 ...
NLN: 非局部神经网络
CV技术指南（微信公众号）
01-05 818
导言： 前面我们介绍了transformer的结构，这一篇是将transformer思想用于CV中的论文，创新点不多，值得写的地方也不多，但还是决定写一下，因为这篇论文可以用来给大家看看transformer用于CV会起到一些什么样的作用，以及transformer可以怎样用于CV中。 介绍transformer结构的时候提到了transformer最大的一个点是可以处理长距离的文本之间的联系，在CV中可以用于处理更大范围的感受野的信息，而不需要通过一层一层的堆叠卷积核来扩大感受野。在N...
lee sir 的编程辛酸之路
baorou6196的博客
07-01 163
首先我们要思考一个问题：为什么要学编程？是兴趣还是薪资？ 会想我当初学编程的时候，完完全全是因为报考大学的时候，分数不过硬，又想去理想的大学被迫而为之。可没想到一入编程深似海～ 这都是后话饿了。 当第一次走进教室门的时候， 发现基本清一色男生，用手指数了数女生仅有3个！ 心中一紧，完了，大学怕是要光棍到底了。 果然四年过去了，当我走出校门的时候我也是孑然一身，潇潇洒洒。 面对着找工作的问题，le...
用c++与easyx实现Nicholl-Lee-Nicholl线段裁剪算法
06-10
Nicholl-Lee-Nicholl（NLN）算法是一种线段裁剪算法，用于在计算机图形学中将线段裁剪到指定的窗口或视口中。它是一种快速而有效的算法，通常用于实时应用程序。 以下是使用C++和EasyX图形库实现NLN算法的代码： ```cpp #include <graphics.h> #include <iostream> using namespace std; // 定义 NLN 算法所需的几个数据结构 struct Point { int x; int y; }; struct Edge { Point p1; Point p2; float dx; float dy; }; struct Window { int left; int top; int right; int bottom; }; // 定义 NLN 算法函数 void NLN(Edge edge, Window window) { float t1 = 0, t2 = 1; float dx = edge.dx; float dy = edge.dy; // 判断线段是否在窗口内 if (dx == 0) { if ((edge.p1.x < window.left) || (edge.p1.x > window.right)) return; } else { float m = dy / dx; float c = edge.p1.y - m * edge.p1.x; float tleft = (window.left - c) / m; float tright = (window.right - c) / m; if (dx > 0) { if (tleft > t1) t1 = tleft; if (tright < t2) t2 = tright; } else { if (tleft < t2) t2 = tleft; if (tright > t1) t1 = tright; } } if (dy == 0) { if ((edge.p1.y < window.top) || (edge.p1.y > window.bottom)) return; } else { float m = dx / dy; float c = edge.p1.x - m * edge.p1.y; float ttop = (window.top - c) / m; float tbottom = (window.bottom - c) / m; if (dy > 0) { if (ttop > t1) t1 = ttop; if (tbottom < t2) t2 = tbottom; } else { if (ttop < t2) t2 = ttop; if (tbottom > t1) t1 = tbottom; } } // 判断线段是否被裁剪 if (t1 <= t2) { Point new_p1, new_p2; new_p1.x = edge.p1.x + t1 * dx; new_p1.y = edge.p1.y + t1 * dy; new_p2.x = edge.p1.x + t2 * dx; new_p2.y = edge.p1.y + t2 * dy; // 绘制裁剪后的线段 line(new_p1.x, new_p1.y, new_p2.x, new_p2.y); } } int main() { // 创建图形窗口 initgraph(640, 480); // 绘制窗口边框 setcolor(WHITE); rectangle(100, 100, 500, 400); // 定义窗口和线段数据 Window window = {100, 100, 500, 400}; Edge edge = {{50, 200}, {600, 200}, 0, 0}; // 计算线段裁剪后的结果并绘制 NLN(edge, window); // 关闭图形窗口 getch(); closegraph(); return 0; } ``` 以上代码中，我们首先定义了三个数据结构：`Point` 代表点的坐标，`Edge` 代表线段的两个端点，以及 `Window` 代表窗口的大小。 然后，我们实现了 `NLN` 函数，该函数接受一个线段和一个窗口作为输入，并计算线段在窗口内的裁剪结果。该函数的实现基于 NLN 算法的基本原理，即通过计算线段与窗口之间的交点来裁剪线段。 最后，我们在 `main` 函数中使用 `NLN` 函数计算线段的裁剪结果，并绘制在图形窗口中。在绘制之前，我们还绘制了一个矩形边框来表示窗口的大小。 运行程序后，将看到裁剪后的线段仅在窗口内被绘制，而窗口外的部分被裁剪掉了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值