代码分享：贝塞尔曲线【空间视频有讲解】

最新推荐文章于 2024-07-16 08:29:44 发布
最新推荐文章于 2024-07-16 08:29:44 发布
阅读量1.6k 收藏
点赞数
文章标签： 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66487663/article/details/122600446
版权

 

 

 

struct xy{
	int x;
	int y;

	xy(){
	}
	xy(int m){
		x=m;
		y=m;
	}
	xy(int x,int y){
		this->x=x;
		this->y=y;
	}

xy operator  *(xy&m){return xy(x *m.x,y *m.y);}
xy operator  /(xy&m){return xy(x /m.x,y /m.y);}
xy operator  %(xy&m){return xy(x %m.x,y %m.y);}
xy operator  +(xy&m){return xy(x +m.x,y +m.y);}
xy operator  -(xy&m){return xy(x -m.x,y -m.y);}
xy operator <<(xy&m){return xy(x<<m.x,y<<m.y);}
xy operator >>(xy&m){return xy(x>>m.x,y>>m.y);}
xy operator  &(xy&m){return xy(x &m.x,y &m.y);}
xy operator  |(xy&m){return xy(x |m.x,y |m.y);}
xy operator  ^(xy&m){return xy(x ^m.x,y ^m.y);}
xy operator  *=(xy&m){x *=m.x;y *=m.y;return *this;}
xy operator  /=(xy&m){x /=m.x;y /=m.y;return *this;}
xy operator  %=(xy&m){x %=m.x;y %=m.y;return *this;}
xy operator  +=(xy&m){x +=m.x;y +=m.y;return *this;}
xy operator  -=(xy&m){x -=m.x;y -=m.y;return *this;}
xy operator <<=(xy&m){x<<=m.x;y<<=m.y;return *this;}
xy operator >>=(xy&m){x>>=m.x;y>>=m.y;return *this;}
xy operator  &=(xy&m){x &=m.x;y &=m.y;return *this;}
xy operator  |=(xy&m){x |=m.x;y |=m.y;return *this;}
xy operator  ^=(xy&m){x ^=m.x;y ^=m.y;return *this;}
xy operator  *(int m){return xy(x *m,y *m);}
xy operator  /(int m){return xy(x /m,y /m);}
xy operator  %(int m){return xy(x %m,y %m);}
xy operator  +(int m){return xy(x +m,y +m);}
xy operator  -(int m){return xy(x -m,y -m);}
xy operator <<(int m){return xy(x<<m,y<<m);}
xy operator >>(int m){return xy(x>>m,y>>m);}
xy operator  &(int m){return xy(x &m,y &m);}
xy operator  |(int m){return xy(x |m,y |m);}
xy operator  ^(int m){return xy(x ^m,y ^m);}
xy operator  *=(int m){x *=m;y *=m;return *this;}
xy operator  /=(int m){x /=m;y /=m;return *this;}
xy operator  %=(int m){x %=m;y %=m;return *this;}
xy operator  +=(int m){x +=m;y +=m;return *this;}
xy operator  -=(int m){x -=m;y -=m;return *this;}
xy operator <<=(int m){x<<=m;y<<=m;return *this;}
xy operator >>=(int m){x>>=m;y>>=m;return *this;}
xy operator  &=(int m){x &=m;y &=m;return *this;}
xy operator  |=(int m){x |=m;y |=m;return *this;}
xy operator  ^=(int m){x ^=m;y ^=m;return *this;}
bool operator  <(xy&m){return((unsigned(x) <unsigned(m.x))&&(unsigned(y) <unsigned(m.y)));}
bool operator  >(xy&m){return((unsigned(x) >unsigned(m.x))&&(unsigned(y) >unsigned(m.y)));}
bool operator <=(xy&m){return((unsigned(x)<=unsigned(m.x))&&(unsigned(y)<=unsigned(m.y)));}
bool operator >=(xy&m){return((unsigned(x)>=unsigned(m.x))&&(unsigned(y)>=unsigned(m.y)));}
bool operator ==(xy&m){return((unsigned(x)==unsigned(m.x))&&(unsigned(y)==unsigned(m.y)));}
bool operator  <(int m){return((unsigned(x) <unsigned(m))&&(unsigned(y) <unsigned(m)));}
bool operator  >(int m){return((unsigned(x) >unsigned(m))&&(unsigned(y) >unsigned(m)));}
bool operator <=(int m){return((unsigned(x)<=unsigned(m))&&(unsigned(y)<=unsigned(m)));}
bool operator >=(int m){return((unsigned(x)>=unsigned(m))&&(unsigned(y)>=unsigned(m)));}
bool operator ==(int m){return((unsigned(x)==unsigned(m))&&(unsigned(y)==unsigned(m)));}
xy operator  !(){return xy( !x, !y);}
xy operator  ~(){return xy( ~x, ~y);}
xy operator  +(){return xy( +x, +y);}
xy operator  -(){return xy( -x, -y);}



	xy get_number(){
		xy m=0;
		if(x>0)m.x=+x;if(x<0)m.x=-x;
		if(y>0)m.y=+y;if(y<0)m.y=-y;
		return m;
	}
	xy get_flag(){
		xy m=0;
		if(x>0)m.x=+1;if(x<0)m.x=-1;
		if(y>0)m.y=+1;if(y<0)m.y=-1;
		return m;
	}


	int sqrt_xx_yy(){
		return sqrt(xx_yy());
	}
	void x_y(){
		int v=x;x=y;y=v;
	}
	int xx(){return x*x;}
	int yy(){return y*y;}
	int xx_yy(){
		return (x*x+y*y);
	}
	
	
	xy operator =(xy&m){
		x=m.x;
		y=m.y;
		return *this;
	}
	xy operator =(int m){
		x=m;
		y=m;
		return *this;
	}
	xy operator ++(int){
		xy temp=*this;
		++x;
		++y;
		return temp;
	}
	xy operator ++(){
		x++;
		y++;
		return *this;
	}

	xy operator --(int){
		xy temp=*this;
		--x;
		--y;
		return temp;
	}
	xy operator --(){
		x--;
		y--;
		return *this;
	}

};

struct xyf{
	float x;
	float y;

	xyf(){
	}
	xyf(float m){
		x=m;
		y=m;
	}
	xyf(float x,float y){
		this->x=x;
		this->y=y;
	}
    xyf(xy m){
		this->x=m.x;
		this->y=m.y;
	}
xyf operator  *(xyf&m){return xyf(x *m.x,y *m.y);}
xyf operator  /(xyf&m){return xyf(x /m.x,y /m.y);}
xyf operator  +(xyf&m){return xyf(x +m.x,y +m.y);}
xyf operator  -(xyf&m){return xyf(x -m.x,y -m.y);}
xyf operator  *=(xyf&m){x *=m.x;y *=m.y;return *this;}
xyf operator  /=(xyf&m){x /=m.x;y /=m.y;return *this;}
xyf operator  +=(xyf&m){x +=m.x;y +=m.y;return *this;}
xyf operator  -=(xyf&m){x -=m.x;y -=m.y;return *this;}
xyf operator  *(float m){return xyf(x *m,y *m);}
xyf operator  /(float m){return xyf(x /m,y /m);}
xyf operator  +(float m){return xyf(x +m,y +m);}
xyf operator  -(float m){return xyf(x -m,y -m);}
xyf operator  *=(float m){x *=m;y *=m;return *this;}
xyf operator  /=(float m){x /=m;y /=m;return *this;}
xyf operator  +=(float m){x +=m;y +=m;return *this;}
xyf operator  -=(float m){x -=m;y -=m;return *this;}




	xyf get_number(){
		xyf m=0;
		if(x>0)m.x=+x;if(x<0)m.x=-x;
		if(y>0)m.y=+y;if(y<0)m.y=-y;
		return m;
	}
	xyf get_flag(){
		xyf m=0;
		if(x>0)m.x=+1;if(x<0)m.x=-1;
		if(y>0)m.y=+1;if(y<0)m.y=-1;
		return m;
	}


	float sqrt_xx_yy(){
		return sqrt(xx_yy());
	}
	void x_y(){
		float v=x;x=y;y=v;
	}
	float xx(){return x*x;}
	float yy(){return y*y;}
	float xx_yy(){
		return (x*x+y*y);
	}
	
	xyf operator =(xy&m){
		x=m.x;
		y=m.y;
		return *this;
	}
	xyf operator =(xyf&m){
		x=m.x;
		y=m.y;
		return *this;
	}
	xyf operator =(float m){
		x=m;
		y=m;
		return *this;
	}
	xyf operator ++(int){
		xyf temp=*this;
		++x;
		++y;
		return temp;
	}
	xyf operator ++(){
		x++;
		y++;
		return *this;
	}

	xyf operator --(int){
		xyf temp=*this;
		--x;
		--y;
		return temp;
	}
	xyf operator --(){
		x--;
		y--;
		return *this;
	}

};




int paint_line(xy r,xy *da){
	// float->int (f+0.5)
	// [-0.5,+0.5)=0
	// [+0.5,+1.5)=1
	// [+1.5,+2.5)=2
    // x*a+b*y=0;
    // (x+v)*a=x*a+v*a;
    // (y+v)*a=y*a+v*a;
    xy n=r.get_number();
    xy f=r.get_flag();
    xy nn=n*2;
    xy d=0;
    xy*db=da;
    *db++=d;
    if(n.y<n.x){
        int v=n.x;
        while(d.x!=r.x){
            d.x+=f.x;
            v-=nn.y;
            if(v<0){
                v+=nn.x;
                d.y+=f.y;
            }
            *db++=d;
        }
    }else{
        int v=n.y;
        while(d.y!=r.y){
            d.y+=f.y;
            v-=nn.x;
            if(v<0){
                v+=nn.y;
                d.x+=f.x;
            }
            *db++=d;
        }
    }
    return (db-da);
}
int paint_line(xy a,xy b,xy *da){
    int dn=paint_line(b-a,da);
    for(int i=0;i<dn;i++)da[i]+=a;
    return dn;
}





/*
struct xy64{
	__int64 x;
	__int64 y;

	xy64(){
	}
	xy64(__int64 m){
		x=m;
		y=m;
	}
	xy64(__int64 x,__int64 y){
		this->x=x;
		this->y=y;
	}

xy64 operator  *(xy64&m){return xy64(x *m.x,y *m.y);}
xy64 operator  /(xy64&m){return xy64(x /m.x,y /m.y);}
xy64 operator  %(xy64&m){return xy64(x %m.x,y %m.y);}
xy64 operator  +(xy64&m){return xy64(x +m.x,y +m.y);}
xy64 operator  -(xy64&m){return xy64(x -m.x,y -m.y);}
xy64 operator <<(xy64&m){return xy64(x<<m.x,y<<m.y);}
xy64 operator >>(xy64&m){return xy64(x>>m.x,y>>m.y);}
xy64 operator  &(xy64&m){return xy64(x &m.x,y &m.y);}
xy64 operator  |(xy64&m){return xy64(x |m.x,y |m.y);}
xy64 operator  ^(xy64&m){return xy64(x ^m.x,y ^m.y);}
xy64 operator  *=(xy64&m){x *=m.x;y *=m.y;return *this;}
xy64 operator  /=(xy64&m){x /=m.x;y /=m.y;return *this;}
xy64 operator  %=(xy64&m){x %=m.x;y %=m.y;return *this;}
xy64 operator  +=(xy64&m){x +=m.x;y +=m.y;return *this;}
xy64 operator  -=(xy64&m){x -=m.x;y -=m.y;return *this;}
xy64 operator <<=(xy64&m){x<<=m.x;y<<=m.y;return *this;}
xy64 operator >>=(xy64&m){x>>=m.x;y>>=m.y;return *this;}
xy64 operator  &=(xy64&m){x &=m.x;y &=m.y;return *this;}
xy64 operator  |=(xy64&m){x |=m.x;y |=m.y;return *this;}
xy64 operator  ^=(xy64&m){x ^=m.x;y ^=m.y;return *this;}
xy64 operator  *(__int64 m){return xy64(x *m,y *m);}
xy64 operator  /(__int64 m){return xy64(x /m,y /m);}
xy64 operator  %(__int64 m){return xy64(x %m,y %m);}
xy64 operator  +(__int64 m){return xy64(x +m,y +m);}
xy64 operator  -(__int64 m){return xy64(x -m,y -m);}
xy64 operator <<(__int64 m){return xy64(x<<m,y<<m);}
xy64 operator >>(__int64 m){return xy64(x>>m,y>>m);}
xy64 operator  &(__int64 m){return xy64(x &m,y &m);}
xy64 operator  |(__int64 m){return xy64(x |m,y |m);}
xy64 operator  ^(__int64 m){return xy64(x ^m,y ^m);}
xy64 operator  *=(__int64 m){x *=m;y *=m;return *this;}
xy64 operator  /=(__int64 m){x /=m;y /=m;return *this;}
xy64 operator  %=(__int64 m){x %=m;y %=m;return *this;}
xy64 operator  +=(__int64 m){x +=m;y +=m;return *this;}
xy64 operator  -=(__int64 m){x -=m;y -=m;return *this;}
xy64 operator <<=(__int64 m){x<<=m;y<<=m;return *this;}
xy64 operator >>=(__int64 m){x>>=m;y>>=m;return *this;}
xy64 operator  &=(__int64 m){x &=m;y &=m;return *this;}
xy64 operator  |=(__int64 m){x |=m;y |=m;return *this;}
xy64 operator  ^=(__int64 m){x ^=m;y ^=m;return *this;}
bool operator  <(xy64&m){return((unsigned(x) <unsigned(m.x))&&(unsigned(y) <unsigned(m.y)));}
bool operator  >(xy64&m){return((unsigned(x) >unsigned(m.x))&&(unsigned(y) >unsigned(m.y)));}
bool operator <=(xy64&m){return((unsigned(x)<=unsigned(m.x))&&(unsigned(y)<=unsigned(m.y)));}
bool operator >=(xy64&m){return((unsigned(x)>=unsigned(m.x))&&(unsigned(y)>=unsigned(m.y)));}
bool operator ==(xy64&m){return((unsigned(x)==unsigned(m.x))&&(unsigned(y)==unsigned(m.y)));}
bool operator  <(__int64 m){return((unsigned(x) <unsigned(m))&&(unsigned(y) <unsigned(m)));}
bool operator  >(__int64 m){return((unsigned(x) >unsigned(m))&&(unsigned(y) >unsigned(m)));}
bool operator <=(__int64 m){return((unsigned(x)<=unsigned(m))&&(unsigned(y)<=unsigned(m)));}
bool operator >=(__int64 m){return((unsigned(x)>=unsigned(m))&&(unsigned(y)>=unsigned(m)));}
bool operator ==(__int64 m){return((unsigned(x)==unsigned(m))&&(unsigned(y)==unsigned(m)));}
xy64 operator  !(){return xy64( !x, !y);}
xy64 operator  ~(){return xy64( ~x, ~y);}
xy64 operator  +(){return xy64( +x, +y);}
xy64 operator  -(){return xy64( -x, -y);}



	xy64 get_number(){
		xy64 m=0;
		if(x>0)m.x=+x;if(x<0)m.x=-x;
		if(y>0)m.y=+y;if(y<0)m.y=-y;
		return m;
	}
	xy64 get_flag(){
		xy64 m=0;
		if(x>0)m.x=+1;if(x<0)m.x=-1;
		if(y>0)m.y=+1;if(y<0)m.y=-1;
		return m;
	}


	__int64 sqrt_xx_yy(){
		return sqrt(xx_yy());
	}
	void x_y(){
		__int64 v=x;x=y;y=v;
	}
	__int64 xx(){return x*x;}
	__int64 yy(){return y*y;}
	__int64 xx_yy(){
		return (x*x+y*y);
	}
	
	
	xy64 operator =(xy64&m){
		x=m.x;
		y=m.y;
		return *this;
	}
	xy64 operator =(__int64 m){
		x=m;
		y=m;
		return *this;
	}
	xy64 operator ++(int){
		xy64 temp=*this;
		++x;
		++y;
		return temp;
	}
	xy64 operator ++(){
		x++;
		y++;
		return *this;
	}

	xy64 operator --(int){
		xy64 temp=*this;
		--x;
		--y;
		return temp;
	}
	xy64 operator --(){
		x--;
		y--;
		return *this;
	}

};
void bezier_call(xy64*sa,int sn,__int64 ti,int bit){
    if(sn<=1)return;
    for(int si=0;(si+1)<sn;si++)sa[si]=sa[si]+(((sa[si+1]-sa[si])*ti)>>bit);
    bezier_call(sa,sn-1,ti,bit);
}
int bezier(xy*sa,int sn,xy*da){
    xy64 ta[4];
    if(1<=sn&&sn<=nof(ta)){}else return 0;
    xy tnxy=0;
    for(int si=0;(si+1)<sn;si++){
       tnxy+=(sa[si+1]-sa[si]).get_number();// abs()
    }
    int tn=tnxy.x+tnxy.y;
    if(tn>0){}else return 0;
    
    int bit;
    for(bit=0;(1<<bit)<tn;bit++);
    tn=1<<bit;/
    if(bit<=16){}else return 0;
    const int bit3=bit*3;
    

    xy64 sa64[nof(ta)];
    for(int i=0;i<sn;i++){
        sa64[i]=xy64(sa[i].x,sa[i].y);
        sa64[i]<<=bit3;
    };

    int dn=0;
    for(int ti=0;ti<tn;ti++){
        
        for(int i=0;i<sn;i++)ta[i]=sa64[i];

        bezier_call(ta,sn,ti,bit);
        xy t(ta[0].x>>bit3,ta[0].y>>bit3);
        
        for(int di=0;1;di++){
            if(di<dn){
                if(t==da[di])break;
            }else{
                da[dn++]=t;
                break;
            }
        }
        
    }
    return dn;
}


*/


void bezier_call(xyf*sa,int sn,float ti_div_tn){
    if(sn<=1)return;
    for(int si=0;(si+1)<sn;si++)sa[si]=sa[si]+(sa[si+1]-sa[si])*ti_div_tn;
    bezier_call(sa,sn-1,ti_div_tn);
}
int bezier(xy*sa,int sn,xy*da){
    xyf ta[100];
    if(1<=sn&&sn<=nof(ta)){}else return 0;
    xy tnxy=0;
    for(int si=0;(si+1)<sn;si++){
       tnxy+=(sa[si+1]-sa[si]).get_number();// abs()
    }
    const int tn=tnxy.x+tnxy.y;
    if(tn==0)return 0;
    if(sn==2){
        return paint_line(sa[0],sa[1],da);
    }
    if(sn==3){
        xyf a=sa[0];
        xyf b=sa[1];
        xyf c=sa[2];
        xyf a_add=(b-a)/tn;
        xyf b_add=(c-b)/tn;
        int dn=0;
        for(int ti=0;ti<tn;ti++){
            xyf tf=a+(b-a)*ti/float(tn);
            a+=a_add;
            b+=b_add;
            xy t(tf.x,tf.y);
            for(int di=0;1;di++){
                if(di<dn){
                    if(t==da[di])break;
                }else{
                    da[dn++]=t;
                    break;
                }
            }   
        }
        return dn;
    }

    if(sn==4){
        xyf a=sa[0];
        xyf b=sa[1];
        xyf c=sa[2];
        xyf d=sa[3];
        xyf a_add=(b-a)/tn;
        xyf b_add=(c-b)/tn;
        xyf c_add=(d-c)/tn;

        int dn=0;
        for(int ti=0;ti<tn;ti++){
            float tt=ti/float(tn);
            xyf ta=a+(b-a)*tt;
            xyf tb=b+(c-b)*tt;
            xyf tf=ta+(tb-ta)*tt;
            a+=a_add;
            b+=b_add;
            c+=c_add;
            xy t(tf.x,tf.y);
            for(int di=0;1;di++){
                if(di<dn){
                    if(t==da[di])break;
                }else{
                    da[dn++]=t;
                    break;
                }
            }
            
        }
        return dn;
    }

    int dn=0;
    for(int ti=0;ti<tn;ti++){
        
        for(int i=0;i<sn;i++)ta[i]=sa[i];

        bezier_call(ta,sn,ti/float(tn));
        xy t(ta[0].x,ta[0].y);
        for(int di=0;1;di++){
            if(di<dn){
                if(t==da[di])break;
            }else{
                da[dn++]=t;
                break;
            }
        }

    }
    return dn;
}

const int g=1;
void sets(void (*set)(int color,xy*da,int dn,int*wa,xy w),int*wa,int width,int height,xy pos){
    xy w(width,height);
    //for(int n=w.x*w.y,i=0;i<n;i++)wa[i]=0;
    xy wn=w/g;
    xy wo=wn/2;
    xy w1=xy(wn.x/4,wn.y/2);
    xy w2=xy(wn.x*3/4,wn.y/2);
    xy wr=pos/g;
    if(wr<wn){
        xy  da[xymax*xymax];
        int dn;


      //dn=paint_line(wo,wr,da);set(0x008000,da,dn,wa,w); 
      //dn=paint_circle(wo,(wr-wo).sqrt_xx_yy(),da),set(0x008000,da,dn,wa,w);
     //dn=paint_ellipse(wo,wr,da);set(0x008000,da,dn,wa,w);


     // dn=fill_line(wo,wr,da,20);set(0x008000,da,dn,wa,w);
        dn=fill_circle(wo,(wr-wo).sqrt_xx_yy(),da),set(0x008000,da,dn,wa,w);
       // dn=fill_ellipse(wo,wr,da);set(0x008000,da,dn,wa,w);


        xy sa[]={wo/2,wo,wr};

        for(int si=0;(si+1)<=nof(sa);si++){dn=paint_line(sa[si%nof(sa)],sa[(si+1)%nof(sa)],da);set(0x808080,da,dn,wa,w); }
        dn=bezier(sa,nof(sa),da);set(0x008000,da,dn,wa,w);


    }

}
// 妄想扣篮的男人 贝塞尔曲线 知识来源：
// 1,九年义务教育
// 2,百度百科 贝塞尔曲线
// 3,微软文档 PolyBezier 
struct get_bezier{
void get(char(*sa)[1000],int sn){
    if(sn<=1)return;
    for(int si=0;(si+1)<sn;si++){
        char a[1000];sprintf(a,"%s",sa[si]);
        sprintf(sa[si],"(%s+(%s-%s)*i_div_n)",a,sa[si+1],a);
    }
    get(sa,sn-1);
}
get_bezier(){
 char da[0x1000];
    const int sn=4;
    char sa[sn][1000];
    for(int si=0;si<sn;si++)sprintf(sa[si],"%c",'a'+si);
    get(sa,sn);
    printf("%s\n",*sa);
// (a+(b-a)*i_div_n)
// ((a+(b-a)*i_div_n)+((b+(c-b)*i_div_n)-(a+(b-a)*i_div_n))*i_div_n)
// (((a+(b-a)*i_div_n)+((b+(c-b)*i_div_n)-(a+(b-a)*i_div_n))*i_div_n)+(((b+(c-b)*i_div_n)+((c+(d-c)*i_div_n)-(b+(c-b)*i_div_n))*i_div_n)-((a+(b-a)*i_div_n)+((b+(c-b)*i_div_n)-(a+(b-a)*i_div_n))*i_div_n))*i_div_n)
    exit(0);
}
}
//get_bezier
;

妄想扣篮的男人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java 贝塞尔曲线_贝塞尔曲线：原理、自定义贝塞尔曲线View、使用！！！
weixin_29661121的博客
02-20 435
一、原理转自：http://www.2cto.com/kf/201401/275838.htmlAndroid动画学习Demo(3) 沿着贝塞尔曲线移动的Property AnimationProperty Animation中最重要，最基础的一个类就是ValueAnimator了。Property Animation利用ValueAnimator来跟踪记录对象属性已经变化了多长时间及当前这个时间...
音视频开发之旅（40)-贝塞尔曲线和曲面
yabin的专栏
04-02 524
目录 贝塞尔曲线基本知识 画贝塞尔曲线 让曲线动起来 画贝塞尔曲面 资料 收获 本篇最终实现效果如下： 篇外说明：由于有必要学习使用下kotlin，后续的java层代码实现尽量采用kotlin 一、贝塞尔曲线基本知识 贝塞尔曲线法国汽车工程师Pierre Bézier在1962年在对汽车主体进行设计时的发明，通过贝塞尔曲线可以设计出优美的车身。 在PS、Sketch等图形软件上我们也经常会看到通过钢笔icon进行贝塞尔曲线的绘画。 贝塞尔曲线至少有一个开始点和结束点，以及n个.
OpenGL 实践之贝塞尔曲线绘制
音视频开发进阶
08-21 1560
说到贝塞尔曲线，大家肯定都不陌生，网上有很多关于介绍和理解贝塞尔曲线的优秀文章和动态图。以下两个是比较经典的动图了。二阶贝塞尔曲线：三阶贝塞尔曲线：由于在工作中经常要和贝...
android贝塞尔曲线实现波浪效果
01-20
本实例主要讲解如何利用贝塞尔曲线来实现波浪效果。以下是对实现这一效果的关键知识点的详细说明： 1. **贝塞尔曲线原理**： 贝塞尔曲线由法国工程师皮埃尔·贝塞尔提出，是一种参数化的插值曲线。在二维空间中，...
C++ 算法教程，贝塞尔曲线计算
06-16
本教程将深入讲解如何使用C++来实现贝塞尔曲线的计算。以下是对贝塞尔曲线及其计算方法的详细解释。 贝塞尔曲线的基本概念： 贝塞尔曲线是由法国工程师皮埃尔·贝塞尔（Pierre Bézier）于1962年提出的，它是一种...
VR贝塞尔曲线移动
01-30
"VR贝塞尔曲线移动"就是这样的一个技术，它利用数学中的贝塞尔曲线来实现3D空间内的精确且平滑的导航。在这个场景中，人物能够在3D环境中通过贝塞尔曲线进行移动，同时还能与环境中的UI交互。以下将详细讲解这个知识...
swift-iOS利用贝塞尔曲线实现的加载动画
08-15
本教程将深入讲解如何利用Swift编程语言和贝塞尔曲线（Bezier Curve）技术来创建一个优雅的加载动画。贝塞尔曲线是一种在图形设计中广泛使用的数学工具，它允许开发者精准地控制曲线的形状和路径。 首先，我们需要...
贝塞尔曲线辅助完成引导界面
06-10
在二维空间中，有三种常见的贝塞尔曲线：线性贝塞尔曲线（仅两个控制点），二次贝塞尔曲线（三个控制点）和三次贝塞尔曲线（四个控制点）。更高次的贝塞尔曲线虽然存在，但在UI设计中较少使用，因为它们通常过于复杂...
07 - FFmpeg 更改视频分辨率 - 保存 yuv420p
weixin_44977283的博客
07-11 410
--------------------------------------------------------------- 更改视频格式流程 ----------------------------------------------------------------4、av_image_get_buffer_size -- 共创建多少字节的空间。解码后的数据存储在data[0]、data[1]、data[2]中，3、av_frame_alloc -- 图像转换后的数据需要存储起来。
05 - FFmpeg 提取 PCM 音频裸数据
weixin_44977283的博客
07-11 491
---------------------------------------------------------------- PCM计算 -----------------------------------------------------------------人耳能接受的频率范围为20Hz～20kHz，故采样率一般为44.1KHz较好，采样率越高，质量越高，但存储空间增大。· 大小计算:以CD的音质为例:量化格式为16比特(2字节)，采样率为44100，声道数为2。
怎么提高音频的播放速度？可以提高音频播放速度的四种方法推荐
ZCR20000的博客
07-11 767
怎么提高音频的播放速度？通过调整播放速度，可以在保持清晰度的同时，加快听取信息的速度。在 Windows Media Player 中，点击左上角的“文件”菜单，然后选择“打开”或者“打开文件”（具体选项名称可能略有不同，取决于你的 Windows 版本）。如果在线工具无法满足您的需求，您还可以考虑使用专业的音频编辑软件，如Audacity、Adobe Audition等，这些软件提供了更强大的音频处理功能。步骤2：接下来，在软件界面的中央空白处或左上角的“添加文件”按钮，选择需要调整播放速度的音频文件。
2024-07-13 Qt6.5版本后视频渲染
ihmhm12345的博客
07-13 976
Qt 6版本中，视频播放能力得到了质的飞越，相对于qt5，变化也很多，具体变化可以看官方说明在Qt5版本中，如果需要播放一个视频，由于后端的解码能力很弱，绝大多数需要写解码的代码，但是在Qt6中，后端加入了ffmpeg，解码已经不是我们所需解决的问题，Qt Multimedia 可以很好的去播放视频但是，在项目中大家可能不止会播放本地视频，很多情况下需要播放在线视频，比较低延时的rtsp流，udp裸流等等。对于需要实时性高的同学来说，qt的后端能力还是没有做好。这时还是需要自己处理视频流。
视频使用操作说明书-T80005系列视频编码器如何对接海康NVR硬盘录像机，包括T80005系列高清HDMI编码器、4K超高清HDMI编码器
weixin_60295046的博客
07-12 493
视频使用操作说明书-T80005系列视频编码器如何对接海康NVR硬盘录像机，包括T80005系列高清HDMI编码器、4K超高清HDMI编码器。
Python 视频水印批量添加器
最新发布
cc605523的博客
07-16 391
三、可添加文本或图片。
音频筑基：入门50问
来知晓的博客
07-12 354
只问不答，意在启发
再升级！视频理解大模型 CogVLM2 开源
机器学习社区
07-13 761
目前，视频理解的主流方法涉及使用图像编码器从视频中提取帧，对其进行编码，然后设计编码压缩模块（如时间池化或Q-Former模块）来压缩视频编码信息，再将其输入大型语言模型（LLM）以便与文本输入进行联合理解。尽管这种方法有效地压缩了视频信息，但它使模型失去了时间感知能力，无法准确地将视频帧与精确的时间戳关联起来。因此，模型缺乏时间定位、时间戳检测和总结关键时刻的能力。为了解决这些问题，我们提出了CogVLM2-Video，这是基于CogVLM2图像理解模型的扩展视频模型。
视频调整帧率、分辨率+音画同步
Ppandaer的博客
07-11 487
【代码】视频调整帧率、分辨率+音画同步。
STFT:解决音频-视频零样本学习 (ZSL) 中的挑战
声纹感知 洞察芯声
07-13 1216
本文提出一种新的Spiking Tucker Fusion Transformer（STFT）用于视听零样本学习，整体性能有了大幅提高。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值