轉載請註明出處：【huachao1001的專欄：http://blog.csdn.net/huachao1001】

*本篇文章已授權微信公衆號 guolin_blog （郭霖）獨家發佈

前面兩篇文章我們介紹了OpenGL相關的基本知識，現在我們已經會繪製基本的圖案了，但是還遠遠不能滿足我們的需求。我們要做的是顯示任意的模型，這也是本文所要做的事情。在閱讀本文之前，請先確保你已經看過我前面兩篇文章：

【Android OpenGL入門】

【Android OpenGL 顯示基本圖形及相關概念解讀】

雖然標題是說顯示任意3D文件，但是本文主要是以STL格式文件爲例。其他的格式本質上都是一樣的，只是解析部分的代碼不同而已。接下來我們開始學習~

1 STL文件

它是標準的3D文件格式，一般3D打印機都是支持打印STL文件，關於STL文件的格式、以及相關介紹請參考百度百科：【stl格式】。當然了，我在代碼的註釋中也會進行相關解釋。

1.1 解析準備

首先，在解析STL文件格式之前，我們需要進行構思。我們無非就是把STL文件中的三角形的頂點信息提取出來。因此我們的主要目標就是把所有點信息讀取出來。

但是，3D模型的座標位置很隨機，大小也隨機。而不同的模型所處的位置不同，爲了能夠讓模型處於手機顯示中心，我們必須對模型進行移動、放縮處理。使得任意大小、任意位置的模型都能在我們的GLSurfaceView中以“相同”的大小顯示。

因此，我們不僅僅要讀取頂點信息，而且還要獲取模型的邊界信息。我們想象成一個立方體，這個立方體剛好包裹住模型。即我們要讀取x、y、z三個方向上的最大值最小值。

1.2 開始解析

首先，我們定義一個Model類，用於表示一個模型對象：

package com.hc.opengl;

import java.nio.FloatBuffer;

/**
 * Package com.hc.opengl
 * Created by HuaChao on 2016/7/28.
 */
public class Model {
    //三角面個數
    private int facetCount;
    //頂點座標數組
    private float[] verts;
    //每個頂點對應的法向量數組
    private float[] vnorms;
    //每個三角面的屬性信息
    private short[] remarks;

    //頂點數組轉換而來的Buffer
    private FloatBuffer vertBuffer;

    //每個頂點對應的法向量轉換而來的Buffer
    private FloatBuffer vnormBuffer;
    //以下分別保存所有點在x,y,z方向上的最大值、最小值
    float maxX;
    float minX;
    float maxY;
    float minY;
    float maxZ;
    float minZ;

    //返回模型的中心點
     //注意，下載的源碼中，此函數修改修正如下
    public Point getCentrePoint() {

        float cx = minX + (maxX - minX) / 2;
        float cy = minY + (maxY - minY) / 2;
        float cz = minZ + (maxZ - minZ) / 2;
        return new Point(cx, cy, cz);
    }

    //包裹模型的最大半徑
    public float getR() {
        float dx = (maxX - minX);
        float dy = (maxY - minY);
        float dz = (maxZ - minZ);
        float max = dx;
        if (dy > max)
            max = dy;
        if (dz > max)
            max = dz;
        return max;
    }

    //設置頂點數組的同時，設置對應的Buffer
    public void setVerts(float[] verts) {
        this.verts = verts;
        vertBuffer = Util.floatToBuffer(verts);
    }

    //設置頂點數組法向量的同時，設置對應的Buffer
    public void setVnorms(float[] vnorms) {
        this.vnorms = vnorms;
        vnormBuffer = Util.floatToBuffer(vnorms);
    }

   //···
   //其他屬性對應的setter、getter函數
   //···

}

接下來就是將stl文件轉換成Model對象，我們定義一個STLReader類:

package com.hc.opengl;

import android.content.Context;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * Package com.hc.opengl
 * Created by HuaChao on 2016/7/28.
 */
public class STLReader {
    private StlLoadListener stlLoadListener;

    public Model parserBinStlInSDCard(String path)
                             throws IOException {

        File file = new File(path);
        FileInputStream fis = new FileInputStream(file);
        return parserBinStl(fis);
    }

    public Model parserBinStlInAssets(Context context, String fileName) 
                            throws IOException {

        InputStream is = context.getAssets().open(fileName);
        return parserBinStl(is);
    }
    //解析二進制的Stl文件
    public Model parserBinStl(InputStream in) throws IOException {
        if (stlLoadListener != null)
            stlLoadListener.onstart();
        Model model = new Model();
        //前面80字節是文件頭，用於存貯文件名；
        in.skip(80);

        //緊接着用 4 個字節的整數來描述模型的三角面片個數
        byte[] bytes = new byte[4];
        in.read(bytes);// 讀取三角面片個數
        int facetCount = Util.byte4ToInt(bytes, 0);
        model.setFacetCount(facetCount);
        if (facetCount == 0) {
            in.close();
            return model;
        }

        // 每個三角面片佔用固定的50個字節
        byte[] facetBytes = new byte[50 * facetCount];
        // 將所有的三角面片讀取到字節數組
        in.read(facetBytes);
        //數據讀取完畢後，可以把輸入流關閉
        in.close();


        parseModel(model, facetBytes);


        if (stlLoadListener != null)
            stlLoadListener.onFinished();
        return model;
    }

    /**
     * 解析模型數據，包括頂點數據、法向量數據、所佔空間範圍等
     */
    private void parseModel(Model model, byte[] facetBytes) {
        int facetCount = model.getFacetCount();
        /**
         *  每個三角面片佔用固定的50個字節,50字節當中：
         *  三角片的法向量：（1個向量相當於一個點）*（3維/點）*（4字節浮點數/維）=12字節
         *  三角片的三個點座標：（3個點）*（3維/點）*（4字節浮點數/維）=36字節
         *  最後2個字節用來描述三角面片的屬性信息
         * **/
        // 保存所有頂點座標信息,一個三角形3個頂點，一個頂點3個座標軸
        float[] verts = new float[facetCount * 3 * 3];
        // 保存所有三角面對應的法向量位置，
        // 一個三角面對應一個法向量，一個法向量有3個點
        // 而繪製模型時，是針對需要每個頂點對應的法向量，因此存儲長度需要*3
        // 又同一個三角面的三個頂點的法向量是相同的，
        // 因此後面寫入法向量數據的時候，只需連續寫入3個相同的法向量即可
        float[] vnorms = new float[facetCount * 3 * 3];
        //保存所有三角面的屬性信息
        short[] remarks = new short[facetCount];

        int stlOffset = 0;
        try {
            for (int i = 0; i < facetCount; i++) {
                if (stlLoadListener != null) {
                    stlLoadListener.onLoading(i, facetCount);
                }
                for (int j = 0; j < 4; j++) {
                    float x = Util.byte4ToFloat(facetBytes, stlOffset);
                    float y = Util.byte4ToFloat(facetBytes, stlOffset + 4);
                    float z = Util.byte4ToFloat(facetBytes, stlOffset + 8);
                    stlOffset += 12;

                    if (j == 0) {//法向量 
                        vnorms[i * 9] = x;
                        vnorms[i * 9 + 1] = y;
                        vnorms[i * 9 + 2] = z;
                        vnorms[i * 9 + 3] = x;
                        vnorms[i * 9 + 4] = y;
                        vnorms[i * 9 + 5] = z;
                        vnorms[i * 9 + 6] = x;
                        vnorms[i * 9 + 7] = y;
                        vnorms[i * 9 + 8] = z;
                    } else {//三個頂點
                        verts[i * 9 + (j - 1) * 3] = x;
                        verts[i * 9 + (j - 1) * 3 + 1] = y;
                        verts[i * 9 + (j - 1) * 3 + 2] = z;

                        //記錄模型中三個座標軸方向的最大最小值
                        if (i == 0 && j == 1) {
                            model.minX = model.maxX = x;
                            model.minY = model.maxY = y;
                            model.minZ = model.maxZ = z;
                        } else {
                            model.minX = Math.min(model.minX, x);
                            model.minY = Math.min(model.minY, y);
                            model.minZ = Math.min(model.minZ, z);
                            model.maxX = Math.max(model.maxX, x);
                            model.maxY = Math.max(model.maxY, y);
                            model.maxZ = Math.max(model.maxZ, z);
                        }
                    }
                }
                short r = Util.byte2ToShort(facetBytes, stlOffset);
                stlOffset = stlOffset + 2;
                remarks[i] = r;
            }
        } catch (Exception e) {
            if (stlLoadListener != null) {
                stlLoadListener.onFailure(e);
            } else {
                e.printStackTrace();
            }
        }
        //將讀取的數據設置到Model對象中
        model.setVerts(verts);
        model.setVnorms(vnorms);
        model.setRemarks(remarks);

    }

    public static interface StlLoadListener {
        void onstart();

        void onLoading(int cur, int total);

        void onFinished();

        void onFailure(Exception e);
    }
}

注意到，我們需要頻繁的將byte數組轉爲short、float類型，我們直接把這些函數裝到一個工具類Util中：

package com.hc.opengl;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

/**
 * Package com.hc.opengl
 * Created by HuaChao on 2016/7/28.
 */
public class Util {

    public static FloatBuffer floatToBuffer(float[] a) {
        //先初始化buffer，數組的長度*4，因爲一個float佔4個字節
        ByteBuffer bb = ByteBuffer.allocateDirect(a.length * 4);
        //數組排序用nativeOrder
        bb.order(ByteOrder.nativeOrder());
        FloatBuffer buffer = bb.asFloatBuffer();
        buffer.put(a);
        buffer.position(0);
        return buffer;
    }

    public static int byte4ToInt(byte[] bytes, int offset) {
        int b3 = bytes[offset + 3] & 0xFF;
        int b2 = bytes[offset + 2] & 0xFF;
        int b1 = bytes[offset + 1] & 0xFF;
        int b0 = bytes[offset + 0] & 0xFF;
        return (b3 << 24) | (b2 << 16) | (b1 << 8) | b0;
    }

    public static short byte2ToShort(byte[] bytes, int offset) {
        int b1 = bytes[offset + 1] & 0xFF;
        int b0 = bytes[offset + 0] & 0xFF;
        return (short) ((b1 << 8) | b0);
    }

    public static float byte4ToFloat(byte[] bytes, int offset) {

        return Float.intBitsToFloat(byte4ToInt(bytes, offset));
    }

}

爲了更好的表示三維座標系下的一個點，我們定義Point類：

/**
 * Package com.hc.opengl
 * Created by HuaChao on 2016/7/28.
 */
public class Point {
    public float x;
    public float y;
    public float z;

    public Point(float x, float y, float z) {
        this.x = x;
        this.y = y;
        this.z = z;

    }
}

2 編寫Render

上一節我們只是拿數據而已，還沒開始繪製，真正的大招現在纔開始。因爲我們目標是顯示任意模型，因此，必須把模型移動到我們的“視野”中，才能看得到（當然了，如果圖形本身就是在我們的視野中，那就不一定需要這樣的操作了）。廢話不多說，直接看源碼：

 /**
 * Package com.hc.opengl
 * Created by HuaChao on 2016/7/28.
 */
public class GLRenderer implements GLSurfaceView.Renderer {

    private Model model;
    private Point mCenterPoint;
    private Point eye = new Point(0, 0, -3);
    private Point up = new Point(0, 1, 0);
    private Point center = new Point(0, 0, 0);
    private float mScalef = 1;
    private float mDegree = 0;

    public GLRenderer(Context context) {
        try {

            model = new STLReader().parserBinStlInAssets(context, "huba.stl");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void rotate(float degree) {
        mDegree = degree;
    }

    @Override
    public void onDrawFrame(GL10 gl) {
        // 清除屏幕和深度緩存
        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);


        gl.glLoadIdentity();// 重置當前的模型觀察矩陣


        //眼睛對着原點看 
        GLU.gluLookAt(gl, eye.x, eye.y, eye.z, center.x,
                center.y, center.z, up.x, up.y, up.z);

        //爲了能有立體感覺，通過改變mDegree值，讓模型不斷旋轉
        gl.glRotatef(mDegree, 0, 1, 0);

        //將模型放縮到View剛好裝下
        gl.glScalef(mScalef, mScalef, mScalef);
        //把模型移動到原點
        gl.glTranslatef(-mCenterPoint.x, -mCenterPoint.y,
                -mCenterPoint.z);


        //===================begin==============================//

        //允許給每個頂點設置法向量
        gl.glEnableClientState(GL10.GL_NORMAL_ARRAY);
        // 允許設置頂點
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
        // 允許設置顏色

        //設置法向量數據源
        gl.glNormalPointer(GL10.GL_FLOAT, 0, model.getVnormBuffer());
        // 設置三角形頂點數據源
        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, model.getVertBuffer());

        // 繪製三角形
        gl.glDrawArrays(GL10.GL_TRIANGLES, 0, model.getFacetCount() * 3);

        // 取消頂點設置
        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
        //取消法向量設置
        gl.glDisableClientState(GL10.GL_NORMAL_ARRAY);

        //=====================end============================//

    }


    @Override
    public void onSurfaceChanged(GL10 gl, int width, int height) {

        // 設置OpenGL場景的大小,(0,0)表示窗口內部視口的左下角，(width, height)指定了視口的大小
        gl.glViewport(0, 0, width, height);

        gl.glMatrixMode(GL10.GL_PROJECTION); // 設置投影矩陣
        gl.glLoadIdentity(); // 設置矩陣爲單位矩陣，相當於重置矩陣
        GLU.gluPerspective(gl, 45.0f, ((float) width) / height, 1f, 100f);// 設置透視範圍

        //以下兩句聲明，以後所有的變換都是針對模型(即我們繪製的圖形)
        gl.glMatrixMode(GL10.GL_MODELVIEW);
        gl.glLoadIdentity();


    }

    @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        gl.glEnable(GL10.GL_DEPTH_TEST); // 啓用深度緩存
        gl.glClearDepthf(1.0f); // 設置深度緩存值
        gl.glDepthFunc(GL10.GL_LEQUAL); // 設置深度緩存比較函數
        gl.glShadeModel(GL10.GL_SMOOTH);// 設置陰影模式GL_SMOOTH
        float r = model.getR();
        //r是半徑，不是直徑，因此用0.5/r可以算出放縮比例
        mScalef = 0.5f / r;
        mCenterPoint = model.getCentrePoint();
    }
}

在MainActivity中不斷調用旋轉函數：

package com.hc.opengl;


public class MainActivity extends AppCompatActivity {

    private boolean supportsEs2;
    private GLSurfaceView glView;
    private float rotateDegreen = 0;
    private GLRenderer glRenderer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        checkSupported();

        if (supportsEs2) {
            glView = new GLSurfaceView(this);
            glRenderer = new GLRenderer(this);
            glView.setRenderer(glRenderer);
            setContentView(glView);
        } else {
            setContentView(R.layout.activity_main);
            Toast.makeText(this, "當前設備不支持OpenGL ES 2.0!", Toast.LENGTH_SHORT).show();
        }
    }

    public void rotate(float degree) {
        glRenderer.rotate(degree);
        glView.invalidate();
    }

    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            rotate(rotateDegreen);
        }
    };

    @Override
    protected void onResume() {
        super.onResume();
        if (glView != null) {
            glView.onResume();

            //不斷改變rotateDegreen值，實現旋轉
            new Thread() {
                @Override
                public void run() {
                    while (true) {
                        try {
                            sleep(100);

                            rotateDegreen += 5;
                            handler.sendEmptyMessage(0x001);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }

                    }
                }
            }.start();
        }


    }

    private void checkSupported() {
        ActivityManager activityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
        ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
        supportsEs2 = configurationInfo.reqGlEsVersion >= 0x2000;

        boolean isEmulator = Build.VERSION.SDK_INT > Build.VERSION_CODES.ICE_CREAM_SANDWICH_MR1
                && (Build.FINGERPRINT.startsWith("generic")
                || Build.FINGERPRINT.startsWith("unknown")
                || Build.MODEL.contains("google_sdk")
                || Build.MODEL.contains("Emulator")
                || Build.MODEL.contains("Android SDK built for x86"));

        supportsEs2 = supportsEs2 || isEmulator;
    }

    @Override
    protected void onPause() {
        super.onPause();
        if (glView != null) {
            glView.onPause();
        }
    }


}

3 最後一步

一切看起來都已經完成了，但似乎少了點什麼。啊哈~，少了STL文件，其實網上有很多STL模型文件免費下載，大家可以隨便搜索。我下載了一個胡巴的模型：

下載完成後，運行如下：

看到結果是不是覺得很失望？貌似看不到輪廓，其實，主要是跟燈光有關，我們程序中沒有設置燈光。我們知道，我們在真實世界中看到物體主要是物體表面發生漫反射。我們所看到的物體跟光源的位置、物體的材質等等有關。另外，也可以通過貼紋理來做到。但是到目前爲止，我們還沒有這些知識，代碼裏面也沒有涉及到這些，因此我們這能看到當前這個樣子。後面我們會繼續深入學習相關知識，歡迎關注~。

好啦，最後獻上源碼吧~，注意，下載的源碼中Model類的getCentrePoint函數需要修改，請以本文中的Model類爲主。

源碼地址：http://download.csdn.net/detail/huachao1001/9588619

Android OpenGL顯示任意3D模型文件

1 STL文件

1.1 解析準備

1.2 開始解析

2 編寫Render

3 最後一步

Tensorflow中float32模型強制轉爲float16半浮點模型 1 加載pb模型 2 重寫BatchNorm 3 Graph轉換 4 完整的代碼

Tensorflow加載預訓練模型的特殊操作 1 只加載部分參數 2 從兩個預訓練模型中加載不同部分參數 3 從參數名稱不一致的模型中加載參數

Tensorflow反捲積（DeConv）實現原理+手寫python代碼實現反捲積（DeConv） 1 反捲積原理 2 代碼實現

【Ubuntu】Tensorflow對訓練後的模型做8位（uint8）量化轉換

OpenVINO運行Tensorflow模型

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結