导出obj后的新闻,自身也在百度社招上面投了简历

五、总结

人生如此多年,尤其目前一两年,计算出了部分体会,分享给我们。

  • 男怕入错行!入了行就不要再换了,换行的代价太高,错就错下去;
  • 一经没有背景,请一定肯定肯定毫无去体制内;
  • 已经进了体制内的,还是百折不挠下去吧;
  • 处理器技术繁荣富强,不变的唯有学习;
  • 人无远虑,必有近忧。不要埋头做技术,要抬眼看世界,规划好和谐的职业生涯和技术途径。

不知不觉一年过去,有成功也有挫折,但无论怎样都要向前看,万一梦想完毕了吧?^-^!

好了,胡言乱语到此结束。祝大家也祝本人二〇一八年得到成功和欢喜!

 

3) 在实际手写的情景下,
文字的墨迹的笔锋首要反映在文字的怎么部位?

三 、这一年经历了哪些

2017开春,办完离职手续,要起来找工作了。因为学习和办事的经历相比复杂,并且存有汽车和总计机双行业内部,老板过大型项目,对项目管理、设计开发、产品测试,以及课题申报、招投标、专利申请、预算结算等都比较明白,算是个多面手,所以刚开首照旧一表非凡、信心满满的。结果…..受打击了。

  所以大家要新建五个txt文件,将内部的数码复制进来,然后把那些文件放在你新建的win32或MFC项目中,将以前的obj从工程中移除。

问题二:
大家平素看三个自家蓄意做得比较不佳的示范图:

② 、为何要出去

体制内的情事不便于细谈,计算正是本人智力商数够,可是情商不够,而且收入实际是低,在京城生活困难,现今没买房子(后悔死了)。跟很多人想的不均等,体制内尚未铁饭碗的,真混不下去,一样有恐怕被辞退。考虑了家中、生活、理想、幸福指数(我是还是不是想多了?),终于照旧控制主动离职,尝试换一条路。出来的时候,笔者已经是高工职称,处级干部待遇,得到过两遍省部级一等奖,一遍二等奖,也算多少底子。

 

上边把C++完毕的源代码分享给我们, 在那之中z_math.h,
z_math.c使用纯c实现,除了c标准库,没有其他任何借助,能够毫无压力的移植到各样帮忙c/c++语言的任何平台.

④ 、未来在做什么

按说说,笔者后天应当在大数目公司,做着本身的项目高管,不会在那边写博客。可事实是自己从大数量公司积极离职了,为啥?

  • 公司固然没明着说996,但周末为首要加班加点;
  • 节奏太快,早上的活不能够拖到中午,更别说过夜;
  • 商店架构复杂,部门提到理不清,存在斗争,下边包车型大巴人不佳干;
  • 每天下班前开会,开着开着就九十点了;
  • 一人当多个人使,刚进入没多长期,就压上海重机厂担;
  • 从前本人是当甲方的,今后当乙方…..

其实,作者内心很精通,上面的原委都不是事,半数以上店铺都这么。真正的原由是在样式内呆了16年,别的没学会,臭毛病倒是一堆。要双休,要有时间照顾家里,要给男女教导作业,要定期训练肉体,要有旅游假期,要工时专擅,要做甲方….由此可见小编真正不适合在店堂集团里。

也是沸腾了好多少个上午,也曾强迫自身适应过,但最终依旧意识到自个儿一度老了,心态不得法了,真的无法在职场里努力了。正好当时,被一句鸡汤迷了–人总要做点自身喜爱的业务,于是不假思索辞职。小编当成个loser啊,太任性了。

辞职干什么吗?当然是钻探协调最喜爱的处理器技术。小编本身对Python和Django还算相比较精晓,于是就从无到有,在Ali云上买了个主机和域名,用Django写了个个人网站,又花了7个月时光,原创了Python教程和Django教程,并免费挂在网上供我们学习。梦想是像前辈那样,靠点击和流量就能生活就行。如今网站开通才3个月,每天已经有几千的PV和几百的UV了,大家的评介还不易。有趣味的能够点击访问,刘江(Liu Jiang)的博客和科目,多提宝贵意见,多谢!

  CINEMA 4D中的正方体:

诸如此类, 大家的线条宽度变化看起来就一发自然了.

3. 某专业行业公司

这家不是自身要好投的。是自个儿在招聘网站下边随手仍了个简历,对方搜索到的。对大商厦有了思想阴歌后,想了想,无法自视太高,应该放下身段。但笔者留了个心眼,网上寻找了须臾间该铺面,评价不太好,管理者比技术职员多。想了想,权当刷一波经历,去探视啊。公司地方在宇宙空间中央,办公环境大、宽敞,但没见到几人,美丽的前台兼文书在嗑瓜子。一番沟通、填表后,来了个女CEO,准备面试。那么些女高管看起来比笔者还紧张,于是自个儿就问了句,你们特邀本人面试的那个“董事长助理”是个什么职位?对方懵了,说照旧让技术官员来啊。于是作者也懵了。

过一会,来了个分管技术的副组长,人挺和蔼,说话不紧相当慢,跟自身介绍了三个钟头公司的情事,作者的头都快点木了。终于进入实质性阶段,原来笔者那几个“董事长助理”岗位指的是间接对董事长负责的技能支援主任。其实这几个时候,作者一度吐弃了该商厦,于是就开了个小编自以为的‘天价’,对方并未立刻回绝,说等董事长回来后决定,然后小编就走了。本以为基本仿佛此了,不会再有关系。没悟出一个礼拜后,对方竟是还电话文告说,他们董事长想约我谈谈,那是同意笔者的价钱了?否则还谈什么?不过本身依然没去,不仅是不想去,也是因为那儿已经获得offer了。

# WaveFront *.mtl file (generated by CINEMA 4D)

newmtl default
Kd 1 1 1

z_math是算法的为主完毕部分:

壹 、人生经验

本身的那半生经验能够简单回顾为:四虚岁上小学、十5虚岁进入某985大学、20岁本科结业,然后进入体制内摸爬滚打16年(在那之中某段时间返校读了业余的处理器学士),叁十六虚岁主动辞去,从样式内出来,成为自由职业者。

人生中经历过的几段重点节点:

  • 没读中等专业高校,而是上了高级中学;
  • 考上了向往的大学,却不曾进去热爱的微处理器专业,而是被调剂到小车正式(原因不详,估计是…你懂的)。但万分时候吗都不懂,也没人指路,傻乎乎的就去了;
  • 01年毕业的时候,没有采取去布里斯班闯荡加入总结机行业,而是进入了体制内,从二个基层技干做起;
  • 07年脱生产和教学习计算机专业硕士学位,为辞职做准备;
  • 不过因为各类原因蹉跎了十年,三十七虚岁才好不简单摒弃工作,从头起先。

  首先在三维软件中开创二个模子。那里笔者以1位体模型演示(只以线框呈现)。

如上内容, 
大约正是手写笔迹算法中享有技术难点和内需留意的底细了.

4.某VTucson创业公司

信用合作社主任娘是自家学弟……年轻有才啊!

信用合作社地点不在市中央,而是某处新开发的商务楼,可是对小编却是很有利。驱车前往,先填表,然后COO初步面试小编。这一面,不得了,分外投机,感觉自个儿的技艺力量和可行性,正是她们要找的要命人。然后CTO也来了,聊得也不利。最终又去跟自家的小业主学弟聊,发现大家也有在圈内的协同熟人,感觉比较承认。这一面正是从清晨到夜幕,最后主任四弟,拉着自作者,指着三个工位说:那便是你的工位了,未来你就是我们的项目牵头了,你明天就复苏入职。笔者当时很狼狈,大家还没谈薪给待遇等难点呢,怎么能如此快吧?于是找了个借口,赶紧出来了。其实,这一个时候,笔者还有其他面试…..

¨好驾驭了数据结构,就能够提取分析obj文件啦

自己消除那么些标题标不二法门是:选取微分的构思,
把线段再一次细分成多条子线段,
宽度的生成均匀的遍布在那几个细分的子线段上.

1. 百度求职

实则笔者最好的做事方向是智能驾乘、无人车辆,差不离是专业绝配啊,并且原来的办事中有从事过那块内容。于是拜托百度的同校帮忙内推,自个儿也在百度社招上面投了简历。但是,石沉大海,未有任何反馈。小编可怜纳闷,难道是简历写的不合适?仔细修改,再投,依旧不行。后来,同学说也许是百度无人平台高层变动,暂停招聘了。好吧,我们无缘。

  注意顶点索引格局,obj里面是以1为基数的,所以在目录时要将索引值减1.则会报越界.

那正是说大家再把这一个难题加大到一种极端的景况:

5. 某大数据集团

那是一家很NB的店堂,就算不著名,但体积相当的大、背景很深,属于潜水的‘巨鳄’,详细不能够说。

在上家V奥迪Q5集团面试后赶紧,就来这家小编投了简历的专营商面试,职位是售前项目COO。对方赏识小编的体裁背景、项目管理经验、招投标经验。面试很简短,直接老板的副首席执行官看了看简历,问了问情况,觉得不错,就带笔者去找H奥迪Q5老总。H汉兰达COO挺好,给本人须要的薪水砍了点….,万幸,我曾经往上抬了点(窃笑),所以最终感觉还算满足。约好明日入职,马上上岗。也就那天,作者接过V中华V公司的对讲机,对方把薪给升高了,还考虑未来能够给点股份,但是必要七日6天的做事。

用作贰个刚从体制内出来的人,笔者对996是很争论的。综合考虑半天,觉得还是这家大数量公司更好点,薪金更高、发展前途更大,而且周末双休(后来才清楚被套路了)。VWrangler在当时,日子不太好过,于是只好对不起学弟了,祝你们事业蓬勃。

而外上边介绍的这几家,小编还面过部分同盟社,有胜有负,就不单独介绍了。

 

想要让笔迹能够有笔锋的作用, 那么整个笔迹肯定不或然是等宽的.也正是说,
要让我们绘制出来的墨迹线条必必要有早晚的粗细变化.

2. 京东求职

相同是无人车方向,也是托朋友关系,简历投递很顺遂,一个星期前边试。进度不详说,技术面试和主持面试都没难题,相当好听,甚至双方在某个地方一度还有过接触,感觉此次稳了。再等了贰个星期,H帕杰罗电话通告去谈待遇,看来基本没难题了。不料,约定时间的前几日又说组长要再面一下,好啊,准备丰盛,又去了。京东对无人平台很尊重啊,小编面试的也不是治本岗,居然出动了老董级别,具体是哪个人笔者就背着了,我们可以百度。当然,小编如此多年体制内摸爬滚打,高级别的决策者也没少见,同桌吃饭,聊聊天也是有过的,肯定不会怯场。聊了有3个钟头,进程也不细说,但感到不太好,恐怕是自身还并未从体制内完全走出去,没有get到对方兴趣点,那事看来悬了。果不其然,十日后,告知落选。看来,笔者和京东也没缘分。

  ¨之所以把五个结构体定义在类的在那之中,二个是不想污源代码,另1个是近期还未曾想到会在别的什么地点会用到他俩.所以近来把她们藏起来

全部人都能够很当然的想到 粗细变化的法则: 一抬手一动脚快的地方必定线条应该更细,
运动慢的的地方细条应该更粗
.是的, 这是最基本的原理,
这一个想法截然正确.

 4.编程

下边作者依据手写的其实际处情状,建议有些标题, 我们能够稍微思考一下:

  

图片 1

  那正是里面包车型大巴音信。

虽说这一个效应大概看起来看尚可, 作为一名追求一帆风顺的程序员,
始终觉得什么地点不对劲.

  ·大家得以看来这么些模型的点面音信太多了,若是直白导出数据太多,处理时先后读取成本的年月太长,而且我们演示也不须要那种高模。

 

  图片 2

问题三:

  图片 3图片 4图片 5

下面!!!!!!!!**自小编只可以重新提起一件很让小编气愤的事体!!!!!!!**

② 、obj中模型导出的安装。

图片 6

 

2) 在骨子里情况中, 须要设置三个相差阈值,
当这一次得到的点, 到上1个点的相距小于那些阈值时, 把那个点吐弃掉,
距离太近, 也是剩下的计算.

  图片 7图片 8

1)  在事实上的状态中, 移动
定位装置(鼠标,手写笔,可能触摸屏)时,
设备发送给大家的mouse_move新闻会分外的多, 要求设置2个

  运营程序:

图片 9

  未标题4.mtl

在笔迹的扫尾地点, 不管从前的线条宽度是多少,
都让其在结尾地点收缩为最小笔宽. 

// 1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <GL/glut.h>
#include<vector>//vector(向量): C++中的一种数据结构,确切的说是一个类.它相当于一个动态的数组,当程序员无法知道自己需要的数组的规模多大时,用其来解决问题可以达到最大节约空间的目的.
#include <fstream>
#include <string>
#include <iostream>

using namespace std;

GLfloat step=0.0,s=0.1,move[]={0,0,0};

class obj3dmodel{
    struct vertex{
        double x,y,z;
    };
    struct face{
        unsigned int v1,v2,v3;
    };
    vector<vertex>vertexs;
    vector<face>faces;

public :
    void parse(const char *filename);
    void draw();
};

void obj3dmodel::parse(const char *filename){
    string s;
    ifstream fin(filename);
    if(!fin)return;
    while(fin>>s){
        switch(*s.c_str()){
        case 'f':
        {
            face f;
            fin>>f.v1>>f.v2>>f.v3;
            cout<<"f      "<<f.v1<<"       "<<f.v2 <<"       "<<f.v3<<endl;
            faces.push_back(f);
        }
        break;

        case 'v':
        {
            vertex v;
            fin>>v.x>>v.y>>v.z;
            cout<<"v      "<<v.x<<"       "<<v.y<<"       "<<v.z<<"       "<<endl;
            this->vertexs.push_back(v);
        }
        break;
        case 'w':break;
        case 'x':break;
        case 'y':break;
        case 'z':break;
        case '#':break;

        default: 
            {}
        break;

        }
    }         
}

void obj3dmodel::draw(){
    glBegin(GL_TRIANGLES);
    for(int i=0;i<faces.size();i++){
        //下标减一
        float move_y=0.5;
        vertex v1=vertexs[faces[i].v1-1];
        vertex v2=vertexs[faces[i].v2-1];
        vertex v3=vertexs[faces[i].v3-1];
        glColor3f(0.3,0.3,0);
        glVertex3f(v1.x,v1.y-move_y,v1.z);

        glColor3f(1,1,0);
        glVertex3f(v2.x,v2.y-move_y,v2.z);

        glColor3f(0.5,0.5,0);
        glVertex3f(v3.x,v3.y-move_y,v3.z);
    }
    glEnd();
}

obj3dmodel obj;

void myinit(){
    GLfloat light_ambient[]={0.3,0.2,0.5};
    GLfloat light_diffuse[]={1,1,1};
    GLfloat light_position[]={2,2,2,1};
    GLfloat light1_ambient[]={0.3,0.3,0.2};
    GLfloat light1_diffuse[]={1,1,1};
    GLfloat light1_position[]={-2,-2,-2,1};
    //灯光
    glLightfv(GL_LIGHT0,GL_AMBIENT,light_ambient);
    glLightfv(GL_LIGHT0,GL_DIFFUSE,light_diffuse);
    glLightfv(GL_LIGHT0,GL_POSITION,light_position);
    glLightfv(GL_LIGHT1,GL_AMBIENT,light1_ambient);
    glLightfv(GL_LIGHT1,GL_DIFFUSE,light1_diffuse);
    glLightfv(GL_LIGHT1,GL_POSITION,light1_position);
    glLightModeli(GL_LIGHT_MODEL_TWO_SIDE,GL_TRUE);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHT1);
    //深度
    glDepthFunc(GL_LESS);
    glEnable(GL_DEPTH_TEST);
    //材质
    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE );
    glEnable(GL_COLOR_MATERIAL);

}

void DrawColorBox(){
    obj.draw();
    //glutSolidTeapot(1);    
}

void display(){
    glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

    /*s+=0.005;
    if(s>1.0)s=0.1;*/  //不进行缩放

    //位移
    //move[0]+=0.005;        //x
    //move[1]+=0.005;        //y
    //move[2]+=0.005;        //z
    //if(move[0]>2)move[0]=0;
    //if(move[1]>2)move[1]=0;
    //if(move[2]>2)move[2]=0;

    glPushMatrix();
    //glScalef(s,s,s);
    //glTranslatef(move[0],move[1],move[2]);
    glRotatef(step,0,1,0);
    //glRotatef(step,0,0,1);
    //glRotatef(step,1,0,0);

    DrawColorBox();
    glPopMatrix();
    glFlush();
    glutSwapBuffers();
}

void stepDisplay(){
    //旋转
    step=step+1;
    if(step>360)step=0;

    display();
}

void myReshape(GLsizei w,GLsizei h){
    glViewport(0,0,w,h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if(w<=h){
        glOrtho(-1.5,1.5,-1.5*(GLfloat)h/(GLfloat)w,1.5*(GLfloat)h/(GLfloat)w,-10,10);
    }else{
        glOrtho(-1.5*(GLfloat)w/(GLfloat)h,1.5*(GLfloat)w/(GLfloat)h,-1.5,1.5,-10,10);
    }
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

void keyboard (unsigned char key,int x,int y){
    switch(key){
    case 27:exit(0);break;
    }
}

int _tmain(int argc, CHAR* argv[])
{
    obj.parse("66.txt");
    //obj.parse("11.txt");
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB);
    glutInitWindowSize(500,400);
    glutCreateWindow("simple");
    myinit();
    glutReshapeFunc(myReshape);
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard);
    glutIdleFunc(stepDisplay);
    glutMainLoop();
    return 0;
}

通过方今两篇小说,
咱们曾经缓解了在手记笔迹中的平滑难点. 本篇将教师怎么样让手写笔迹能够有笔锋效果.

  这里,大家定义四个结构体来代表顶点和三角形,并运用vector容器来保存数据组.

事实上,
假如完全依据一种线性的转移关系,
绘制出来的线条会看起来分外奇怪(亲测完全如此).

  

一经大家有哪些不了解只怕笔者说得不常常的地点,
可以在留言区留言.作者会尽量回答.

  小编感觉那样就知足自笔者的需求,早先时期运转程序读取数据不会超越4分钟

图片 10

 

  • min( abs(k*s – W_previous), distance * K_width_unit_change)
    (k * s-W_previous) >=
    0

      W_previous
  • min( abs(k*s – W_previous), distance * K_width_unit_change)
    (k * s-W_previous) <
    0

      W_current      
    当前线段的上升幅度
      W_previous    与近日线条相邻的前一条线段的宽度
      distance
             当前线条的尺寸
      w_k
            设定的3个永恒阈值,表示:单位距离内,
    笔迹的线条宽度能够转移的最大批量.
      distance *
    w_k     即为当前线段的尺寸内, 笔宽能够相对于前一条线段笔宽的基础上,
    最多能够变宽也许能够变窄多少.
    其一函数多引入了1个变量(前一条线段的宽度,
    还有当前的线条的偏离), 在测算线条宽度时,
    考虑了越多的大概
    .
    充实了一种非线性的更动机制,
    min.那几个min就是大家的”激活函数”.让大家的线宽不再只具有线性的变通了.

    当今, 那一个总结线宽的函数,看起来已经相比较健全了.

  obj中存放的是顶点坐标音信(v),面包车型客车消息(f),法线(vn),纹理坐标(vt),以及材质(那几个位于mtl)中

  时间阈值,
比如前三遍新闻到这一回音信的间隔时间小于30阿秒, 就把那一个点遗弃掉. 不然,
点太多, 每种都处理, 基本上都以多余的计算..

  导出obj后的音讯

 演示程序下载 

  图片 11

 

class obj3dmodel{
    struct vertex{
        double x,y,z;
    };
    struct face{
        unsigned int v1,v2,v3;
    };
    vector<vertex>vertexs;
    vector<face>faces;

public :
    void parse(const char *filename);
    void draw();
};

 

  分析:

最终呈现一张在缓解那几个难点时,留下的手迹:

  将丰裕文件用VS打开后,可以见见当中的数量,那里大家要拍卖一下:

  W_previous

  在VS中查找“#”初阶的,有以下两句话,然后直接删除这些是自小编用CINEM卡罗拉D导出后自带的,会惊动程序的运作。

世家假如大家认为那篇文章对您有扶持,
又愿意打赏一些银两, 请拿起你的无绳电话机, 打开你的微信,
扫一扫下方二维码, 作为3个有骨气的程序员攻城狮,
作者可怜愿意承受咱们的支助…哈哈哈!!!

void obj3dmodel::parse(const char *filename){
    string s;
    ifstream fin(filename);
    if(!fin)return;
    while(fin>>s){
        switch(*s.c_str()){
        case 'f':
        {
            face f;
            fin>>f.v1>>f.v2>>f.v3;
            cout<<"f      "<<f.v1<<"       "<<f.v2 <<"       "<<f.v3<<endl;
            faces.push_back(f);
        }
        break;

        case 'v':
        {
            vertex v;
            fin>>v.x>>v.y>>v.z;
            cout<<"v      "<<v.x<<"       "<<v.y<<"       "<<v.z<<"       "<<endl;
            this->vertexs.push_back(v);
        }
        break;
        case 'w':break;
        case 'x':break;
        case 'y':break;
        case 'z':break;
        case '#':break;

        default: 
            {}
        break;

        }
    }         
}

void obj3dmodel::draw(){
    glBegin(GL_TRIANGLES);
    for(int i=0;i<faces.size();i++){
        //下标减一
        float move_y=0.5; //控制模型的位置
        vertex v1=vertexs[faces[i].v1-1];
        vertex v2=vertexs[faces[i].v2-1];
        vertex v3=vertexs[faces[i].v3-1];
        glColor3f(0.3,0.5,0);
        glVertex3f(v1.x,v1.y-move_y,v1.z);

        glColor3f(1,1,0);
        glVertex3f(v2.x,v2.y-move_y,v2.z);

        glColor3f(0.5,0.5,0);
        glVertex3f(v3.x,v3.y-move_y,v3.z);
    }
    glEnd();
}

在笔迹转角的职位体现出笔锋看起来相比劳顿,
但是在笔迹起头和了结的地点做一些稿子如故比较简单.

1.关于obj的说明。

实在那里也反映了”非线性”变化的思辨,
因为小编认为这点相比首要, 所以单独建议来.

 

1) 假若大家的乘除线条笔宽的函数就是:
W_current = k * s,
当中s为当前线段笔迹点运动的快慢,
k为将速度映射为笔宽的一个固定全面.

用户移动时,
获得了3个相邻的点依次分别为:a,b,c, 在ab线段, 移动速度接近无限大,
而在bc段移动的快慢最好接近0,

其实, 在手记笔迹的时候,完全有大概前一段移动速度非常的慢, 到下一段距离的时候,
移动速度就立刻变得极慢了.

自身只是把恐怕遇到的处境开展了浮夸, 那么,
在那种境况下,我们应该如何处理线条的粗细呢?

  模型解析:

解决以上二个难题, 离那几个算法的打响,
就还差点细节的标题了.(纵然是细节难点,
然则以下那多少个须要注意的细节11分可怜可怜关键,
说三遍!!!!!!!)

  小编动用CINEMA 4D导出用VS查看后的音信:

一样, 大家在处理手写笔迹的时候,
线条的粗细也不该完全和进程是一种线性的成形关系,.

 3.数据处理

下边小编就不买关子, 直接报告大家须求小心的地点:

  模型处理后:

上面大家分别讨论那一个问题.
问题一:
比方完全依据线性函数W_current = k * s
来总计宽度, 相邻两端线条的笔宽变化有大概这些大,
大到过量了小编们得以的接受范围.

故而大家考虑通过某种格局来界定那种突然的转移,
让线条宽度的转移看起来更自然.

上面是自家改进之后的盘算线条宽度的函数:
W_current =

  ·还有就是,大家清楚OpenGl中的运转后可视化界面包车型大巴坐标是重-1到1,那里能够旁观这几个模型的尺码太大,大家务必开始展览缩放。

就此, 在盘算线条粗细的时候, 在依据”速度越快的地点,线条更细;
速度慢的地点,线条更粗” 这一条基本准则的前提下,
也应该依照局地具体情形, 让线条的粗细变化全部”非线性”的能力.

  图片 12

 

作者:feiquan

出处:http://www.cnblogs.com/feiquan/

版权声明:本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。

大家写文都不容易,请尊重劳动成果~ 这里谢谢大家啦(*/ω\*)

说点题外话, 方今在看机器学习, 神经互联网模型里面有一个叫:激活函数的事物,
它的意义正是为了让神经互连网具有分层的非线性映射学习的力量,
假使完全是线性的, 在拍卖有些复杂气象时,获得的结果会很不好.

  图片 13图片 14图片 15

更好的理由笔者也说不出来为啥,应该是属于程序员的第柒感吗,
感觉那样做会比较好. 而且事实评释效果的确不错.

¨大家同时为她定义了parse和draw方法,分别用来从文件中剖析数据和动用opengl绘制

 

  

在平常的书写进度中,
笔锋首要反映在笔画的序幕地点,
转角地点, 和笔画截止的地方.

  图片 16

自作者的具体做法是如此, 在笔迹开首的前四个点(这么些’5′,
是自身任由想出来的, 也可4,6,7,8), 让笔迹的宽细变化更为扎眼

  

 

  VS固然可以向来打开obj可是从那些里面是心有余而力不足读取数据的。

手写笔迹那三个种类总算是写完了.在这几篇原创小说中,
小编有广大地方没有主意完全把团结的想法表明清楚,那只怕也是多多益善程序员攻城狮的瑕疵,
表明能力不怎样.

  模型导出:注意一下之下地点就好,因为那边只要点(v),面(f)其余会搅乱,也会使程序功能下跌。导出后唯有以下二个文本。

  1 /*
  2 =====================================================================================
  3  *       Filename:  z_math.h
  4  *    Description:  
  5  *        Version:  2.0
  6  *        Created:  06/23/2016 14:53:43
  7  *       Revision:  none
  8  *       Compiler:  gcc
  9  *         Author:  zl(88911562@qq.com), 
 10  *   Organization:  
 11  * =====================================================================================
 12  */
 13 //_________________________________
 14 // stl on mac location is:
 15 // /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1
 16 // Mac OS X 10.9+ no longer uses GCC/libstdc++ but uses libc++ and Clang.
 17 //---------------------------------
 18 //td c++ (STL, streams, ...) : Modified libstdc++ headers for use with ctags 
 19 //use ctags for c++(stl,streams....)
 20 //www.vim.org/scripts/script.php?script_id=2358
 21 //ctags -R --c++-kinds=+p --fields=+ias --extra=+q --language-force=c++ cpp_src 
 22 //sudo ctags -R --c++-kinds=+p --fields=+ias --extra=+q --language-force=c++ ./
 23 //================================= */
 24 #ifndef z_math_h_
 25 #define z_math_h_
 26 
 27 #ifdef __cplusplus
 28 extern "C" {
 29 #endif
 30     
 31 #include <stdint.h>
 32 
 33 typedef struct z_point_s  z_point;
 34 typedef struct z_fpoint_s z_fpoint;
 35 typedef struct z_ipoint_s z_ipoint;
 36 typedef struct z_fpoint_array_s z_fpoint_array;
 37 typedef struct z_fpoint_arraylist_node_s  z_fpoint_arraylist_node;
 38 typedef struct z_fpoint_arraylist_s z_fpoint_arraylist;
 39 
 40 struct z_point_s {
 41     float x, y;
 42 };
 43 
 44 struct z_fpoint_s{
 45     z_point p;
 46     float w;
 47 };
 48 
 49 struct z_ipoint_s {
 50     z_point p;
 51     int64_t t;
 52 };
 53 
 54 struct z_fpoint_array_s {
 55     z_fpoint *point;
 56     float maxwidth;
 57     float minwidth;
 58     int ref;
 59     int len;
 60     int cap;
 61 
 62     z_point last_point;
 63     float last_width;
 64     int64_t last_ms;
 65 };
 66 
 67 struct z_fpoint_arraylist_node_s {
 68     z_fpoint_array *a;
 69     z_fpoint_arraylist_node *n;
 70 };
 71 
 72 struct z_fpoint_arraylist_s {
 73     int ref;
 74     z_fpoint_arraylist_node *first;
 75     z_fpoint_arraylist_node *end;
 76     z_fpoint_arraylist_node *cur;
 77 };
 78 
 79 z_fpoint_array *z_keep_fpoint_array(z_fpoint_array *a);
 80 void z_drop_fpoint_array(z_fpoint_array *a);
 81 
 82 z_fpoint_arraylist* z_keep_fpoint_arraylist(z_fpoint_arraylist *l);
 83 void z_drop_fpoint_arraylist(z_fpoint_arraylist *l);
 84 
 85 z_fpoint_array *z_new_fpoint_array(int initsize, float maxwidth, float minwidth);
 86 z_fpoint_array *z_resize_fpoints_array(z_fpoint_array* a, int size);
 87 
 88 z_fpoint_arraylist *z_new_fpoint_arraylist();
 89 void z_fpoint_arraylist_append(z_fpoint_arraylist *l, z_fpoint_array *a);
 90 // must be drop after used
 91 z_fpoint_array *z_fpoint_arraylist_append_new(z_fpoint_arraylist *l, float maxwidth, float minwidth);
 92 void z_fpoint_arraylist_removelast(z_fpoint_arraylist *l);
 93 
 94 float z_movespeed(z_ipoint s, z_ipoint e);
 95 float z_distance(z_point s, z_point e);
 96 void  z_fpoint_add_xyw(z_fpoint_array *a, float x, float y, float w);
 97 void  z_fpoint_add(z_fpoint_array *a, z_fpoint p);
 98 void  z_fpoint_differential_add(z_fpoint_array *a, z_fpoint p);
 99 void  z_square_bezier(z_fpoint_array *a, z_fpoint b, z_point c, z_fpoint e);
100 float z_linewidth(z_ipoint b, z_ipoint e, float w, float step);
101 
102 float z_insert_point(z_fpoint_array *arr, z_point point);
103 void  z_insert_last_point(z_fpoint_array *arr, z_point e);
104 
105 
106 typedef struct z_list_node_s z_list_node;
107 struct z_list_node_s {
108     void *data; 
109     z_list_node *n;
110     z_list_node *p;
111 }; 
112 typedef void*(*z_list_node_alloc_fun)();
113 typedef void(*z_list_node_drop_fun) (void *data);
114 
115 
116 struct z_list_s {
117     z_list_node_alloc_fun alloc;
118     z_list_node_drop_fun  drop;
119     z_list_node *first;
120     z_list_node *last;
121 };
122 typedef struct z_list_s z_list;
123 
124 z_list *z_list_new(z_list_node_alloc_fun allocfun, z_list_node_drop_fun dropfun);
125 void *z_list_append_new(z_list *zlist);
126 void *z_list_remove_last(z_list *zlist);
127 void z_list_clear(z_list *zlist);
128 void z_list_free(z_list *zlist);
129 
130 /* digest must be 33 char size  */
131 // void z_text_md5(const char* str, char *digest);
132 
133 #ifdef __cplusplus
134 }
135 #endif
136 
137 #endif

  1 /*
  2 =====================================================================================
  3  *       Filename:  z_math.c
  4  *    Description:
  5  *        Version:  1.0
  6  *        Created:  06/23/2016 14:53:43
  7  *       Revision:  none
  8  *       Compiler:  gcc
  9  *         Author:  zl(88911562@qq.com), 
 10  *   Organization:  
 11  * =====================================================================================
 12  */
 13 #include <math.h>
 14 #include <stdio.h>
 15 #include <string.h>
 16 #include <stdlib.h>
 17 #include <time.h> 
 18 #include "z_math.h"
 19 
 20 #define z_malloc_struct(t) (t*)calloc(1, sizeof(t))
 21 static void* z_malloc_array(unsigned int count, unsigned int size);
 22 static void* z_resize_array(void *p, size_t count, size_t size);
 23 
 24 static void z_fpoint_array_set_last_info(z_fpoint_array *arr, z_point last_point, float last_width);
 25 
 26 /***************************** mac stdlib location:
 27 Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/usr/include/stdio.h
 28 */
 29 static float z_square(float f){ return (float)f*f; };
 30 static float z_cubic_(float f){ return (float)powf(f, 3); };
 31 
 32 typedef struct z_bezier_factors_s {
 33     float bezier_step;      // must be divisible by 1.0f
 34     float max_width_diff;   // max width diff between two near lines
 35     float max_move_speed;   // 
 36     float max_linewith;     
 37 } z_bezier_factors ;
 38 
 39 int z_point_equals(z_point *p1, z_point *p2) {
 40     return (p1->x==p2->x&&p1->y==p2->y) ? 1 : 0;
 41 }
 42 
 43 z_fpoint_array *z_keep_fpoint_array(z_fpoint_array *a) {
 44     if(a) a->ref++;
 45     return a;
 46 }
 47 
 48 void z_drop_fpoint_array(z_fpoint_array *a) {
 49     if(!a) return;
 50 
 51     if( !(--(a->ref)) ) {
 52         free(a);
 53     }
 54 }
 55 
 56 z_fpoint_arraylist *z_keep_fpoint_arraylist(z_fpoint_arraylist *l) {
 57     if(!l) return NULL;
 58     l->ref++;
 59     return l;
 60 }
 61 
 62 void z_drop_fpoint_arraylist(z_fpoint_arraylist *l) {
 63     if(!l) return;
 64 
 65     if( !(--(l->ref)) ) {
 66         z_fpoint_arraylist_node *c = l->first;
 67         z_fpoint_arraylist_node *n;
 68         while(c) {
 69             z_drop_fpoint_array(c->a);
 70             n = c->n;
 71             free(c);
 72             c = n;
 73         }
 74     } 
 75 }
 76 
 77 static const float defualt_max_width = 5.0f;
 78 static const float default_min_width = 1.0f;
 79 
 80 z_fpoint_array *z_new_fpoint_array(int initsize, float maxwidth, float minwidth) {
 81     if(initsize<=0) return NULL;
 82     z_fpoint_array *a = malloc(sizeof(z_fpoint_array));
 83     a->point = z_malloc_array(initsize, sizeof(z_fpoint));
 84     a->ref = 1;
 85     a->len = 0;
 86 
 87     if(maxwidth<0 || minwidth<0 || maxwidth<minwidth ){
 88         maxwidth = defualt_max_width;
 89         minwidth = default_min_width;
 90     }
 91 
 92     a->maxwidth = maxwidth;
 93     a->minwidth = minwidth;
 94 
 95     a->cap = initsize;
 96     return a;
 97 }
 98 
 99 z_fpoint_array *z_resize_fpoints_array(z_fpoint_array* a, int count){
100     if(!a || count<=0) return NULL;
101 
102     a->point = (z_fpoint*)z_resize_array(a->point, count, sizeof(z_fpoint));
103     a->cap = count;
104     a->len = min(a->cap, a->len);
105     return a;
106 }
107 
108 z_fpoint_arraylist *z_new_fpoint_arraylist() {
109     z_fpoint_arraylist *l = z_malloc_struct(z_fpoint_arraylist);
110     l->ref = 1;
111     l->first = l->end = NULL;
112     return l;
113 }
114 
115 void z_fpoint_arraylist_append(z_fpoint_arraylist *l, z_fpoint_array *a) {
116     z_fpoint_arraylist_node *node = z_malloc_struct(z_fpoint_arraylist_node);
117     node->a = z_keep_fpoint_array(a);
118     node->n = NULL;
119 
120     if(!l->first) {
121         l->first = node;
122     }
123     else {
124         l->end->n = node;
125     }
126 
127     l->end = node;
128 }
129 
130 z_fpoint_array *z_fpoint_arraylist_append_new(z_fpoint_arraylist *l, float max, float min) {
131     z_fpoint_array *a = z_new_fpoint_array(24, max, min);
132     z_fpoint_arraylist_append(l, a);
133     printf("append new points array\n");
134     return a; 
135 }
136 
137 void z_fpoint_arraylist_removelast(z_fpoint_arraylist *l) {
138     
139     z_fpoint_arraylist_node *c = l->first;
140 
141     z_drop_fpoint_array(l->end->a);
142     free(l->end);
143 
144     while(c->n != l->end) { c = c->n; }
145 
146     c->n = NULL;
147     l->end = c; 
148 }
149 
150 z_fpoint_array *z_auto_increase_fpoints_array(z_fpoint_array *a) {
151     int cap = a->cap + (a->cap+3)/4;
152     return z_resize_fpoints_array(a, cap);
153 }
154 
155 float z_movespeed(z_ipoint s, z_ipoint e) {
156     float d = z_distance(s.p, e.p);
157     return (0==d) ? 0 : d/(e.t-s.t);
158 }
159 
160 float z_distance(z_point b, z_point e){
161     return (float)sqrtf( z_square(e.x-b.x) + z_square(e.y-b.y) );
162 }
163 
164 void  z_fpoint_add_xyw(z_fpoint_array *a, float x, float y, float w)  {
165     if( !a || (a->point[a->len-1].p.x==x && a->point[a->len-1].p.y==y) ) return;
166     
167     if(a->len==a->cap) 
168         z_auto_increase_fpoints_array(a);
169 
170     z_fpoint *p = a->point + (a->len++);
171     p->p.x = x; p->p.y = y; p->w = w;
172 }
173 
174 void  z_fpoint_add(z_fpoint_array *a, z_fpoint p) {
175     z_fpoint_add_xyw(a, p.p.x, p.p.y, p.w);
176 }
177 
178 void  z_fpoint_differential_add(z_fpoint_array *a, z_fpoint p) {
179     if(!a) return; 
180 
181     if( a->len==0 ) {
182         z_fpoint_add(a, p);
183         return;
184     }
185 
186 // #define bad_show
187 #ifdef bad_show
188     z_fpoint_add(a, p);
189     return;
190 #endif
191     float max_diff = 0.1f;
192     z_fpoint *last = a->point + (a->len-1);
193     z_point sp = last->p;
194     float sw = last->w;
195     
196     int n = (int)((fabsf(p.w - last->w) / max_diff) + 1);
197     float x_step = (p.p.x - sp.x) / n;
198     float y_step = (p.p.y - sp.y) / n;
199     float w_step = (p.w - sw)      / n;
200     
201     int i;
202     for(i=0; i<(n-1); i++ ){
203         sp.x += x_step;
204         sp.y += y_step;
205         sw += w_step;
206         z_fpoint_add_xyw(a, sp.x, sp.y, sw);
207     }
208     z_fpoint_add(a, p);
209 }
210 
211 void  z_square_bezier(z_fpoint_array *a, z_fpoint b, z_point c, z_fpoint e){
212     if(!a) return;
213     const float f = 0.1f;
214     for(float t=f; t<=1.0; t+=f ) {
215         float x1 = z_square(1-t)*b.p.x + 2*t*(1-t)*c.x + z_square(t)*e.p.x;
216         float y1 = z_square(1-t)*b.p.y + 2*t*(1-t)*c.y + z_square(t)*e.p.y;
217         float w = b.w + (t* (e.w-b.w));
218         z_fpoint pw = { {x1, y1}, w};
219         z_fpoint_differential_add(a, pw);
220     }
221 }
222 
223 float z_linewidth(z_ipoint b, z_ipoint e, float bwidth, float step) {
224     const float max_speed = 2.0f;
225     float d = z_distance(b.p, e.p);
226     float s = d / (e.t - b.t); s = s > max_speed ? max_speed : s;
227     float w = (max_speed-s) / max_speed;
228     float max_dif = d * step;
229     if( w<0.05f ) w = 0.05f;
230     if( fabs( w-bwidth ) > max_dif ) {
231         if( w > bwidth )
232             w = bwidth + max_dif;
233         else
234             w = bwidth - max_dif;
235     }
236     // printf("d:%.4f, time_diff:%lld, speed:%.4f, width:%.4f\n", d, e.t-b.t, s, w);
237     return w;
238 }
239 
240 
241 float z_insert_point(z_fpoint_array *arr, z_point point) {
242 
243     if(!arr) return 0;
244     int len = arr->len;
245 
246     z_point zp = {point.x, point.y};
247     if( 0==len ){
248         z_fpoint p = {zp, 0.4f};
249         z_fpoint_add(arr, p); 
250         z_fpoint_array_set_last_info(arr, point, p.w);
251         return p.w;
252     }
253 
254     int64_t cur_ms = clock();
255     float last_width = arr->last_width;
256     int64_t last_ms = arr->last_ms;
257     z_point last_point = arr->last_point;
258 
259     printf("cur_ms - last_ms = 0x%llx\n", cur_ms - last_ms);
260     // 两次采样时间小于25毫秒, 或者距离小于2个像素, 不采样计算!!!  
261     float distance = z_distance(point, last_point);
262     if( (cur_ms-last_ms) < 50 || distance < 3) {
263         return 0;
264     }
265 
266     float step = arr->len > 4 ? 0.05f : 0.2f;
267     z_ipoint bt = { {last_point.x,last_point.y}, last_ms};
268     z_ipoint et = { zp, cur_ms};
269     float w = (z_linewidth(bt, et, last_width, step) + last_width) / 2;
270     z_fpoint_array *points = z_new_fpoint_array(51, arr->maxwidth, arr->minwidth);
271     z_fpoint tmppoint = arr->point[len-1];
272     z_fpoint_add(points, tmppoint);
273 
274     if( 1==len ) {
275         z_fpoint p = { {(bt.p.x + et.p.x + 1) / 2, (bt.p.y + et.p.y +1) / 2}, w};
276         z_fpoint_differential_add(points, p);
277         w = p.w;
278     }
279     else {
280         z_fpoint bw = tmppoint;
281         z_point c =  {last_point.x,last_point.y};
282         z_fpoint ew = {{(last_point.x + point.x)/2, (last_point.y + point.y)/2}, w};
283         z_square_bezier(points, bw, c, ew);
284     }
285     
286     // escape the first point
287     int i;
288     for(i=1; i<points->len; i++) {
289         z_fpoint_add(arr, points->point[i]);
290     }
291 
292     z_drop_fpoint_array(points); 
293     z_fpoint_array_set_last_info(arr, point, w);
294 
295     return w;
296 }
297 
298 void z_insert_last_point(z_fpoint_array *arr, z_point e) {
299     if(!arr) return;
300     long len= arr->len;
301     if(len==0 ) return;
302     z_fpoint_array *points = z_new_fpoint_array(51, arr->maxwidth, arr->minwidth);
303     z_fpoint zb = arr->point[len-1];
304     z_fpoint_add(points, zb);
305     
306     z_fpoint ze = { {e.x, e.y}, 0.1f};
307     z_fpoint_differential_add(points, ze);
308     int i;
309     for(i=1; i<points->len; i++) {
310         z_fpoint_add(arr, points->point[i]);
311     }
312     z_drop_fpoint_array(points);
313 }
314 
315 z_list *z_list_new(z_list_node_alloc_fun allocfun, z_list_node_drop_fun dropfun)
316 {
317     z_list *l = NULL;
318     l = z_malloc_struct(z_list);
319     l->alloc = allocfun;
320     l->drop = dropfun;
321     l->first = l->last = NULL;
322     return l;
323 }
324 
325 void *z_list_append_new(z_list *zlist) 
326 {
327     z_list_node *node = NULL;
328     void *data = NULL;
329 
330     if(!zlist->alloc || !zlist->drop) 
331         return NULL;
332 
333     node = z_malloc_struct(z_list_node);
334     node->data = zlist->alloc();
335     node->n = NULL;
336     node->p = NULL;
337 
338     if(node) {
339         if(!zlist->first) {
340             zlist->first = zlist->last = node;
341         }
342         else {
343             node->n = NULL;
344             node->p = zlist->last;
345             zlist->last->n = node; 
346             zlist->last = node;
347         } 
348         data = node->data;
349     }
350 
351     return data;
352 }
353 void *z_list_remove_last(z_list *zlist) 
354 {
355     void *data = NULL;
356     z_list_node *tmp = zlist->last;
357     if(zlist->last) {
358         tmp = zlist->last;
359         if(zlist->last==zlist->first){
360             zlist->last = zlist->first = NULL;
361         }
362         else {
363             zlist->last = tmp->p;
364             zlist->last->n = NULL;
365         }
366     }
367 
368     if(tmp) {
369         data = tmp->data; 
370         free(tmp);
371     }
372 
373     return data; 
374 }
375 
376 void z_list_clear(z_list *zlist) 
377 {
378     while (zlist->first)
379         zlist->drop(z_list_remove_last(zlist));
380 }
381 
382 void z_list_free(z_list *zlist) 
383 {
384     z_list_clear(zlist);
385     free(zlist);
386 }
387 
388 /* digest must be 33 char size  */
389 // void
390 // z_text_md5(const char* str, char *digest)
391 // {
392 //     int len = strlen(str);
393 //     unsigned char d[16];
394 //     fz_md5 state;
395 //     fz_md5_init(&state);
396 //     fz_md5_update(&state, (const unsigned char*)str, len);
397 //     fz_md5_final(&state, d);
398 // 
399 //     int i;
400 //     for(i=0; i<(int)sizeof(d); i++) {
401 //         sprintf(digest, "%02x", d[i]);
402 //         digest+=2;
403 //     }
404 //     *digest = '\0';
405 // }
406 
407 void* z_malloc_array(unsigned int count, unsigned int size) { 
408     unsigned int totalsize = count * size;
409     if (totalsize <= 0) return 0;
410 
411     void *buffer = malloc(count * size);
412     if(buffer) memset(buffer, 0, count * size);
413     return buffer;
414 }
415 
416 void* z_resize_array(void *p, size_t count, size_t size) {
417     void *np = 0;
418     size_t total_size = count * size;
419 
420     if (total_size <= 0) 
421         return np; 
422 
423     np = realloc(p, total_size);
424 
425     return np;
426 }
427 
428 void z_fpoint_array_set_last_info(z_fpoint_array *arr, z_point last_point, float last_width) {
429     if (!arr) return;
430     arr->last_point = last_point;
431     arr->last_ms = clock();
432     arr->last_width = last_width; 
433     printf("reset last ms to 0x%llx\n", arr->last_ms);
434 }

源码提供:

无良专营商总老董拖欠三个月薪资了, 
穷得叮当响
,我靠!!!!!!!!现在天天吃8块钱的蛋炒饭,
上午点一份,早晨吃二分一, 深夜吃50%, 日子真实苦啊..

  模型不是2个一体化,分层太多,导出后种种模块的数码是分开的。

2) 同样要是贰个点, 两条线条ab, bc, cd,
并且借使ab, bc有丰富的尺寸,
使得大家计算出来的上升幅度变化看起来也是相比合理的,
这样说也许不太简单精晓.

举个栗子: ab, bc的线条长度都为玖17个像素,
总括出ab线段线条的大幅应该是5, bc线段的线条宽度该是10,

从真正手写的境况来看,
200个像素长度的字迹, 只有多个像素的宽窄变化,那是全然创立的.

那便是说,倘若大家用宽度5来绘制线段ab,
然后用宽度10来绘制线段bc, 大家绘制出来的笔迹是什么样子的?
(发挥一下想象力)

  VS中查看;未标题4.obj

那般难点就很醒目了.

  大家了解OpenGL中创立不规则模型能够经过点和三角面来制造。那么大家要做的正是从obj中程导弹出点的三维信息和面包车型客车三维音讯。

欢喜的时节总是过得那么快,
留下的连天无尽的唏嘘和感慨, 又到时间和爱人们讲拜拜了!!!

  

  图片 17

 

# WaveFront *.obj file (generated by CINEMA 4D)

mtllib ./未标题4.mtl

v -100 -100 100
v -100 100 100
v 100 -100 100
v 100 100 100
v 100 -100 -100
v 100 100 -100
v -100 -100 -100
v -100 100 -100
# 8 vertices

vn 0 0 1
vn 1 0 0
vn 0 0 -1
vn -1 0 0
vn 0 1 0
vn 0 -1 0
# 6 normals

vt 0 0 0
vt 0 1 0
vt 1 1 0
vt 1 0 0
# 4 texture coordinates

o 立方体
usemtl default
f 3/4/1 4/3/1 2/2/1 1/1/1
f 5/4/2 6/3/2 4/2/2 3/1/2
f 7/4/3 8/3/3 6/2/3 5/1/3
f 1/4/4 2/3/4 8/2/4 7/1/4
f 4/4/5 6/3/5 8/2/5 2/1/5
f 5/4/6 3/3/6 1/2/6 7/1/6

5.运转结果:

  图片 18

          低模                                                
               高模

  图片 19图片 20

  ¨分析这个多少,简单估摸obj文件由若干行组成,每行开首有三个字母,用来标注改行数据所代表的意趣,v
应该是顶点,g应该是二个名字,观看到,f后紧跟着四个整数,由opengl中的顶点数组得到,他应该是三角行的两极分化,前面包车型客车五个整数就意味着着前端顶点的目录值.

·   图片 21图片 22

  

相关文章