FillPology.hpp

浏览该文件的文档.

//
//  FillPology.hpp
//  多线程
//
//  Created by 赵明明 on 2023/6/15.
//
#pragma once
#ifndef FillPology_hpp
#define FillPology_hpp
 
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include "矩阵.hpp"
#include <vector>
#include "线.hpp"
#include <cmath>
 
using namespace std;
 
 
class FillPology
{
public:
    int plane_index;
    矩阵 * points=NULL;
    矩阵 * vns=NULL;
    矩阵 * 视线=NULL;
    矩阵 * 左右扫描点=NULL;
    vector<矩阵*> select_pos;
    矩阵 * pmin=NULL;
    矩阵 * pmax=NULL;
    矩阵* 坐标阵[];
public:
    FillPology(){
        坐标阵[0]=NULL;
        坐标阵[1]=NULL;
        
    };
    
    FillPology(矩阵* 多边形顶点,矩阵* 法线=NULL,矩阵* view_vector=NULL,int plane_index=0){
        points=多边形顶点;
        vns=法线;
        视线=view_vector;
        //select_pos=NULL;
        坐标阵[0]=NULL;
        坐标阵[1]=NULL;
        this->plane_index=plane_index;
        
    }
    
    矩阵*  get_scan(void){
        矩阵* minmax=NULL;
        
        
        minmax=points->minmax(0);
        pmin=((*minmax)["0,:"]);
        pmax=((*minmax)["1,:"]);
        //cout<<*(pmax);
        //cout<<*(pmin);
        
        线 线1=线(0.2,0.5);
        //矩阵* 左右扫描点=NULL;
        int ymax=(int)((*pmax)[1]);//向下取整
        int ymin=(int)((*pmin)[1]);//向上取整
        
        int step=0;
        if(ymax>ymin){
            step =(ymax-ymin)/((int)ymax-(int)ymin);
        }else if (ymax==ymin){
            float data[4]={(*pmin)[0],(float)ymax,(*pmax)[0],(float)ymax};
            矩阵* 左右点=new 矩阵(2,2,data,1);
            if(!左右扫描点){
                左右扫描点=左右点;
            }else{
                左右扫描点=左右扫描点->r_(左右扫描点,左右点);
            }
            // 确保每条扫描线得到两个点。 扫面线的数据是左右扫描点的1/2
            //cout<<"扫描线: "<<((int)ymax-(int)ymin)+1<<","<<左右扫描点->h<<endl;
            assert( ((ymax-ymin)+1)*2 == 左右扫描点->h );
            
            //cout<<*左右扫描点;
            return 左右扫描点;
            
        }
        
        
        for(float y=ymin;y<ymax+1;y+=step){
            float data[4]={(*pmin)[0],(float)y,(*pmax)[0],(float)y};
            int imax=points->h;//被扫描边数
            int imin=0;//被扫描边的开始序号
            // 判断y在某个顶点上，且不在上下边界
            bool y_in_edge_flag=((y-ymin<step) or (ymax-y<step)) or (y-ymin==0) or(ymax-y==0);
            // 判断当前扫描线是否位于两条边的交点， -1 表示不在交点
            int y_in_point_index=-1;
            矩阵 差=(*(*points)[":,1"])-y;
            float y_in_point_flag[4]={0,0,0,0};
            for(int 差i=0;差i<差.h;差i++){
                if(abs(差[差i])<step*0.5 or abs(差[差i])==0){
                    y_in_point_flag[差i]=1;
                    
                    if((y_in_point_flag[0]+y_in_point_flag[1]==1) and 差i==2 and imax==4){imax=imax-1;}// 当序号为0,2的点在扫描线上时，不扫描最后一条边
                    
                    y_in_point_index=差i;// 存储多边形上的、在扫描线上的最后一个点、的序号
                }
            }
            矩阵 旗 =  矩阵(1,4,y_in_point_flag,1);
            
            if((旗.和())->data[0]==3){imax = points->h;}// 如果4边形有3个点都在扫描线上
            if(旗[1]==1 and 旗[3]==1 and (旗.和())->data[0]==2){imin=1;}
            矩阵 扫描线=矩阵(2,2,(float *)data,1);
            
            for(int i=imin;i<imax;i++){
                矩阵* 边=NULL;
                if(i<points->h-1){
                    stringstream ss;
                    ss<<i<<":"<<i+2<<",:";
                    边=(*points)[ss.str()];
                    
                }
                else if(i==points->h-1){
                    stringstream ss;
                    ss<<i<<",:";
                    边=points->r_((*points)[ss.str()],(*points)["0,:"]);
                }
                /*
                cout<<"扫描线:";
                cout<<扫描线;
                cout<<"边:";
                cout<<*(边);
                */
                
                float 被替换的序号2=0;
                边->取整();
                扫描线.取整();
                // 如果边与扫描线共线
                if(边->data[1]==边->data[3] and 边->data[1]==扫描线[1]){
                    //什么也不做，因为左右两个端点在构成其他边的时候，可以被求取出来
                }
                else{// 如果边与扫描线不共线
                    矩阵* 交点2=线1.线段交点(*边,扫描线,&被替换的序号2);
                    /*cout<<"多边形,边，扫描线，交点"<<endl;
                    cout<<*points;
                    cout<<*边;
                    cout<<扫描线;
                    cout<<*交点2;
                     */
                    if( 被替换的序号2 != 线1.Inf){
                        if(!左右扫描点){
                            左右扫描点=new 矩阵(*交点2);
                        }else{
                            左右扫描点=左右扫描点->r_(左右扫描点,交点2);
                        }
                    }
                    //扫描两条边的交点处时，如果交点不是上下限点，就跳过两条边中的一条，
                    //避免扫描到四边形的某个顶点时，计算得到2个左点或者2个右点
                    if(!y_in_edge_flag){
                        
                        if(y_in_point_index==i+1){//如果线段的第2个点是交点，那就就不再扫描以第二个点为起点的线段
                            i=i+1;
                        }
                        if(y_in_point_index==i and i==0){//如果只有序号为0的点在扫描线上，那么不扫描最后一条边
                            imax=imax-1;
                        }
                    }
                    
                }
            }
            //cout<<"左右扫描点"<<endl;
            //cout<<(*左右扫描点);
        }
        // 确保每条扫描线得到两个点。 扫面线的数据是左右扫描点的1/2
        //cout<<"plane_index:"<<plane_index<<"  扫描线: "<<((int)ymax-(int)ymin)+1<<","<<左右扫描点->h<<endl;
        assert( ((ymax-ymin)+1)*2 == 左右扫描点->h );
        
        //cout<<*左右扫描点;
        return 左右扫描点;
    }
    
    矩阵* get_select_pos_from_scan(矩阵* 左右扫描点){
        矩阵* select_pos_return=NULL;
        矩阵* minmax=NULL;
        minmax=points->minmax(0);
        pmin=((*minmax)["0,:"]);
        pmax=((*minmax)["1,:"]);
        float minx=(*pmin)[0];
        float miny=(*pmin)[1];
        float maxx=(*pmax)[0];
        float maxy=(*pmax)[1];
        
        select_pos_return = new 矩阵(maxy-miny+1,maxx-minx+1,0);
        for(int j=0;j<maxy-miny;j+=1){
                float x1=(*左右扫描点)[0+j*4];
                float x2=(*左右扫描点)[2+j*4];
                float y=(*左右扫描点)[1+j*4];
                //cout<<x1<<","<<x2<<","<<y<<endl;
                // 交换x1和x2的值
                if(x1>x2){
                    x1=x1+x2;
                    x2=x1-x2;
                    x1=x1-x2;
                }
                for(int x=x1;x<x2+1;x++){
                    select_pos_return->data[x-(int)minx+(int)(round(y)-miny)*select_pos_return->w]=1;
                }
        }
        select_pos.insert(select_pos.end(),select_pos_return);
        return select_pos_return;
    }
    
    矩阵* fill_color(矩阵 * img, float * color){
        矩阵* select_pos_return=NULL;
        *color=need_display();
        //cout<<*color<<endl;
        if(*color<0){ return select_pos_return;}
        if(!左右扫描点){
            get_scan();
        }
        
        矩阵* minmax=NULL;
        minmax=points->minmax(0);
        pmin=((*minmax)["0,:"]);
        pmax=((*minmax)["1,:"]);
        float minx=(*pmin)[0];
        float miny=(*pmin)[1];
        float maxx=(*pmax)[0];
        float maxy=(*pmax)[1];
        
        select_pos_return = new 矩阵(maxy-miny+1,maxx-minx+1,0);
        //assert(img->h==select_pos_return->h);
        //assert(img->w==select_pos_return->w);
        
        for(int j=0;j<maxy-miny;j+=1){
                float x1=(*左右扫描点)[0+j*4];
                float x2=(*左右扫描点)[2+j*4];
                float y=(*左右扫描点)[1+j*4];
                //cout<<x1<<","<<x2<<","<<y<<endl;
                // 交换x1和x2的值
                if(x1>x2){
                    x1=x1+x2;
                    x2=x1-x2;
                    x1=x1-x2;
                }
                // x=x+1开始填色，尝试避免抖动,经实验发现，虽然不抖动了，但是会出现一些黑点。这是由于从x+1开始，带来的副作用.
                
                if(( (int)(x1*1000)-((int)x1)*1000)>0){ //为避免上述副作用，只在当x为小数时，向上取整。实验发现，两个平面的边缘部分不再抖动了。只剩下物体边缘的平面在抖动。这个不是这里能够解决的了。因为是平面法线不准确，造成本不应该被完全显示的平面，进行了完全显示，遮挡了前方的平面。
                    x1=int(x1+1);
                }
            
                for(float x=x1;x<x2;x++){
                    select_pos_return->data[(int)x-(int)minx+(int)(round(y)-(int)miny)*select_pos_return->w]=1;
                    /*
                    if(vns->h==4){
                        矩阵 点=矩阵(1,2,(float)0);
                        点[0]=x;
                        点[1]=y;
                        *color = cacu_color(&点);
                        
                    }*/
                     
                    if(*color>0){
                        img->data[(int)x+(int)round(y)*img->w]=*color;
                    }
                    
                }
        }
        return select_pos_return;
    }
    
    float need_display(void){
        if(!视线){
            float view[]={0,0,1};
            视线=new 矩阵(1,3,view,1);
        }
        // 差值法计算的发现是错误的，直接用第一个点的发线来计算亮度
        //矩阵* 亮度=法线.点积(视线);
        矩阵 *暂时法线=(*((*vns).和(0))).单位化();
        /*cout<<*vns;
        cout<<*((*vns).和(0));
        cout<<*暂时法线;
        cout<<视线;
        */矩阵* 亮度=暂时法线->点积(*视线);
        //cout<<*暂时法线;
        //cout<<"亮度:"<<亮度->data[0]<<endl;
        亮度->data[0]=-亮度->data[0];
        if(亮度->data[0]<0){亮度->data[0]=0;}
        return 亮度->data[0];
    }
    
    float cacu_color(矩阵 * 点){
        //float color=0.5;
        //cout<<*点;
        //cout<<vns->w<<","<<vns->h<<endl;
        //cout<<*vns;
        
        // 计算a,b,c,d: a = norm(view) 点积 norm(vns)
        // 计算ar,br,cr,dr
        //计算pu,pb
        //计算pur pdr
        //计算p
        矩阵 横差=*points - 点->data[0];
        // 计算
        float pax=横差[0];
        float pbx=-横差[1];
        // ar,br
        float puw[]={pbx/(pax+pbx),pax/(pax+pbx)};
        矩阵 PUW=矩阵(1,2,puw,1);
        矩阵* aby_=(*(*points)["0:2,:"])[":,1"];
        aby_->转置();
        // 计算y ,即pu,
        矩阵* puy=PUW.点积(*aby_);
        // 计算法线
        矩阵 上法线=*((*vns)["0,:"])*PUW[0]+*((*vns)["1,:"])*PUW[1];
        
        
        float pcx=横差[2];
        float pdx=-横差[3];
        // cr ,dr
        float pdw[]={pdx/(pcx+pdx),pcx/(pcx+pdx)};
        矩阵 PDW=矩阵(1,2,pdw,1);
        矩阵* cdy_=(*(*points)["2:4,:"])[":,1"];
        cdy_->转置();
        // 计算y, 即pd
        矩阵* pdy=PDW.点积(*cdy_);
        // 计算法线
        矩阵 下法线=*((*vns)["2,:"])*PUW[0]+*((*vns)["3,:"])*PUW[1];
        
        
        矩阵* PUD = pdy->c_(puy,pdy);
        
        矩阵 纵差=*PUD - 点->data[1];
        
        float puyd=纵差[0];
        float pdyd=-纵差[1];
        // pur pdr
        float pudw[]={pdyd/(puyd+pdyd),puyd/(puyd+pdyd)};
        矩阵 PUDW=矩阵(1,2,pudw,1);
        // 计算p
        矩阵* py=PUDW.点积(*PUD);
        // 计算法线,即，计算p
        矩阵 法线=(上法线)*PUDW[0]+(下法线)*PUDW[1];
        
        float view[]={0,0,1};
        矩阵 视线=矩阵(1,3,view,1);
        // 差值法计算的发现是错误的，直接用第一个点的发线来计算亮度
        //矩阵* 亮度=法线.点积(视线);
        矩阵*  暂时法线=((*vns)["0,:"]);
        矩阵* 亮度=暂时法线->点积(视线);
        //cout<<*暂时法线;
        //cout<<"亮度:"<<亮度->data[0]<<endl;
        亮度->data[0]=-亮度->data[0];
        if(亮度->data[0]<0){亮度->data[0]=0;}
        
        return 亮度->data[0];
    }
    
    矩阵*  get_select_pos(int plane_index){
        矩阵* minmax=NULL;
        矩阵* select_pos_return=NULL;
        
        minmax=points->minmax(0);
        pmin=((*minmax)["0,:"]);
        pmax=((*minmax)["1,:"]);
        //cout<<*(pmax);
        //cout<<*(pmin);
        矩阵* 行x=minmax->arange((*pmin)[0],(*pmax)[0]+1);
        //cout<<*行x;
        
        矩阵* 行y=minmax->arange((*pmin)[1],(*pmax)[1]+1);
        //cout<<*行y;
        
        
        //矩阵* 坐标阵[]={NULL,NULL};
        minmax->meshgrid( 行x, 行y,坐标阵);
        //cout<<"矩阵* 坐标阵=minmax->meshgrid( 行x, 行y);"<<endl;
        //cout<<*(坐标阵[0]);
        //cout<<*(坐标阵[1]);
        矩阵* last_compare=NULL;
        //vector<矩阵*> select_pos;
        for(int i=-1;i<points->h-1;i++){
            stringstream ss1,ss2;
            ss1<<i+1<<",:";
        
            if(i==-1){ss2<<points->h-1<<",:";}
            else{ss2<<i<<",:";}
            矩阵 p01=*((*points)[ss1.str()])-*((*points)[ss2.str()]);
            
            矩阵 xd=(*坐标阵[0])-(*points)[i*points->w];
            
            矩阵 yd=(*坐标阵[1])-(*points)[i*points->w+1];
            
            矩阵 p01xy=yd*p01[0];
            矩阵 p01xx=xd*p01[1];
            矩阵 p01x = p01xy-p01xx;
            
            矩阵 p01xz=(p01x>=0);
            //cout<<p01xz;
            
            if(i>=0){
                vector<矩阵*>::iterator it;
                it=select_pos.end();
                //cout<<(*last_compare);
                //cout<<p01xz;
                矩阵 等阵= (*last_compare)==p01xz;
                //cout<<等阵;
                select_pos.insert(it,new 矩阵(等阵));
                //cout<<等阵;
            }
            
            if(i>=1){
                矩阵 乘阵=(*(select_pos[i]))*(*(select_pos[i-1]));
                //cout<<乘阵;
                select_pos[i]=new 矩阵(乘阵);
            }
            
            last_compare=new 矩阵(p01xz);
            //cout<<*last_compare;
            
       }
        
        //cout<<*(select_pos[select_pos.size()-1]);
        矩阵* last_sp=select_pos[select_pos.size()-1];
        select_pos_return = new 矩阵(last_sp->h,last_sp->w,last_sp->data,1);
        
        return select_pos_return;
    };
    int * fill_color(int * img, float * color){
        
        return img;
    };
    
    int * fill_img(int* img,float * img_color,int *select_pos_z,int plane_index){return img;};
    
    void fill_test(){std::cout<<"fill_test"<<std::endl;};
};
#endif /* FillPology_hpp */