surround_view/service-impl/ObjReader.cpp - platform/packages/services/Car - Git at Google

 /*
  * Copyright 2020 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #include "ObjReader.h"

 #include <array>
 #include <cstdio>
 #include <filesystem>
 #include <vector>

 #include "MtlReader.h"
 #include "core_lib.h"

 #include <android-base/logging.h>

 namespace android {
 namespace hardware {
 namespace automotive {
 namespace sv {
 namespace V1_0 {
 namespace implementation {

 using android_auto::surround_view::CarMaterial;
 using android_auto::surround_view::CarVertex;

 namespace {

 constexpr int kNumberOfVerticesPerFace = 3;
 constexpr int kNumberOfAxes = 3;
 constexpr int kCharBufferSize = 128;

 const std::array<float, 16> kMat4Identity = {
         /*row 0*/ 1, 0, 0, 0,
         /*row 1*/ 0, 1, 0, 0,
         /*row 2*/ 0, 0, 1, 0,
         /*row 3*/ 0, 0, 0, 1};

 // Copies face vertices parsed from obj to car vertices.
 void CopyFaceToCarVertex(const std::vector<std::array<float, kNumberOfAxes>>& currentVertices,
                          const std::vector<std::array<float, kNumberOfAxes>>& currentTextures,
                          const std::vector<std::array<float, kNumberOfAxes>>& currentNormals,
                          int vertexId, int textureId, int normalId, CarVertex* carVertex) {
     std::memcpy(carVertex->pos.data(), currentVertices[vertexId - 1].data(),
                 currentVertices[vertexId - 1].size() * sizeof(float));

     if (textureId != -1) {
         std::memcpy(carVertex->tex_coord.data(), currentTextures[textureId - 1].data(),
                     2 * sizeof(float));
         // Set texture coodinates as invalid.
         carVertex->tex_coord = {-1.0, -1.0};
     }

     std::memcpy(carVertex->normal.data(), currentNormals[normalId - 1].data(),
                 currentNormals[normalId - 1].size() * sizeof(float));
 }

 }  // namespace

 bool ReadObjFromFile(const std::string& objFilename, std::map<std::string, CarPart>* carPartsMap) {
     return ReadObjFromFile(objFilename, ReadObjOptions(), carPartsMap);
 }

 bool ReadObjFromFile(const std::string& objFilename, const ReadObjOptions& option,
                      std::map<std::string, CarPart>* carPartsMap) {
     FILE* file = fopen(objFilename.c_str(), "r");
     if (!file) {
         LOG(ERROR) << "Failed to open obj file: " << objFilename;
         return false;
     }

     for (int i = 0; i < kNumberOfAxes; ++i) {
         if (option.coordinateMapping[i] >= kNumberOfAxes || option.coordinateMapping[i] < 0) {
             fclose(file);
             LOG(ERROR) << "coordinateMapping index must be less than 3 and greater or equal "
                           "to 0.";
             return false;
         }
     }

     std::vector<std::array<float, kNumberOfAxes>> currentVertices;
     std::vector<std::array<float, kNumberOfAxes>> currentNormals;
     std::vector<std::array<float, kNumberOfAxes>> currentTextures;
     std::map<std::string, MtlConfigParams> mtlConfigParamsMap;
     std::string currentGroupName;
     MtlConfigParams currentMtlConfig;

     while (true) {
         char lineHeader[kCharBufferSize];
         // read the first word of the line
         int res = fscanf(file, "%s", lineHeader);

         if (res == EOF) {
             break;  // EOF = End Of File. Quit the loop.
         }
         if (strcmp(lineHeader, "#") == 0) {
             fgets(lineHeader, sizeof(lineHeader), file);
             continue;
         }

         // TODO(b/156558814): add object type support.
         // TODO(b/156559272): add document for supported format.
         // Only single group per line is supported.
         if (strcmp(lineHeader, "g") == 0) {
             res = fscanf(file, "%s", lineHeader);
             currentGroupName = lineHeader;
             currentMtlConfig = MtlConfigParams();

             if (carPartsMap->find(currentGroupName) != carPartsMap->end()) {
                 LOG(WARNING) << "Duplicate group name: " << currentGroupName
                              << ". using car part name as: " << currentGroupName << "_dup";
                 currentGroupName.append("_dup");
             }
             carPartsMap->emplace(
                     std::make_pair(currentGroupName,
                                    CarPart((std::vector<CarVertex>()), CarMaterial(), kMat4Identity,
                                            std::string(), std::vector<std::string>())));
             continue;
         }

         // no "g" case, assign it as default.
         if (currentGroupName.empty()) {
             currentGroupName = "default";
             currentMtlConfig = MtlConfigParams();
             carPartsMap->emplace(
                     std::make_pair(currentGroupName,
                                    CarPart((std::vector<CarVertex>()), CarMaterial(), kMat4Identity,
                                            std::string(), std::vector<std::string>())));
         }

         if (strcmp(lineHeader, "usemtl") == 0) {
             res = fscanf(file, "%s", lineHeader);

             // If material name not found.
             if (mtlConfigParamsMap.find(lineHeader) == mtlConfigParamsMap.end()) {
                 carPartsMap->at(currentGroupName).material = CarMaterial();
                 LOG(ERROR) << "Material not found: $0" << lineHeader;
                 return false;
             }

             currentMtlConfig = mtlConfigParamsMap[lineHeader];

             carPartsMap->at(currentGroupName).material.ka = {currentMtlConfig.ka[0],
                                                              currentMtlConfig.ka[1],
                                                              currentMtlConfig.ka[2]};

             carPartsMap->at(currentGroupName).material.kd = {currentMtlConfig.kd[0],
                                                              currentMtlConfig.kd[1],
                                                              currentMtlConfig.kd[2]};

             carPartsMap->at(currentGroupName).material.ks = {currentMtlConfig.ks[0],
                                                              currentMtlConfig.ks[1],
                                                              currentMtlConfig.ks[2]};

             carPartsMap->at(currentGroupName).material.d = currentMtlConfig.d;

             carPartsMap->at(currentGroupName).material.textures.clear();

             continue;
         }

         if (strcmp(lineHeader, "mtllib") == 0) {
             res = fscanf(file, "%s", lineHeader);
             mtlConfigParamsMap.clear();
             std::string mtlFilename;
             if (option.mtlFilename.empty()) {
                 mtlFilename = objFilename.substr(0, objFilename.find_last_of("/"));
                 mtlFilename.append("/");
                 mtlFilename.append(lineHeader);
             } else {
                 mtlFilename = option.mtlFilename;
             }
             if (!ReadMtlFromFile(mtlFilename, &mtlConfigParamsMap)) {
                 LOG(ERROR) << "Parse MTL file " << mtlFilename << " failed.";
                 return false;
             }
             continue;
         }

         if (strcmp(lineHeader, "v") == 0) {
             std::array<float, kNumberOfAxes> pos;
             fscanf(file, "%f %f %f\n", &pos[option.coordinateMapping[0]],
                    &pos[option.coordinateMapping[1]], &pos[option.coordinateMapping[2]]);
             for (int i = 0; i < kNumberOfAxes; ++i) {
                 pos[i] *= option.scales[i];
                 pos[i] += option.offsets[i];
             }
             currentVertices.push_back(pos);
         } else if (strcmp(lineHeader, "vt") == 0) {
             std::array<float, kNumberOfAxes> texture;
             fscanf(file, "%f %f %f\n", &texture[0], &texture[1], &texture[2]);
             currentTextures.push_back(texture);
         } else if (strcmp(lineHeader, "vn") == 0) {
             std::array<float, kNumberOfAxes> normal;
             fscanf(file, "%f %f %f\n", &normal[option.coordinateMapping[0]],
                    &normal[option.coordinateMapping[1]], &normal[option.coordinateMapping[2]]);
             currentNormals.push_back(normal);
         } else if (strcmp(lineHeader, "f") == 0) {
             int vertexId[kNumberOfVerticesPerFace];
             int textureId[kNumberOfVerticesPerFace] = {-1, -1, -1};
             int normalId[kNumberOfVerticesPerFace];

             // Face vertices supported formats:
             // With texture:     pos/texture/normal
             // Without texture:  pos//normal

             // Scan first vertex position.
             int matches = fscanf(file, "%d/", &vertexId[0]);

             if (matches != 1) {
                 LOG(WARNING) << "Face index error. Skipped.";
                 fgets(lineHeader, sizeof(lineHeader), file);
                 continue;
             }

             // Try scanning first two face 2 vertices with texture format present.
             bool isTexturePresent = true;
             matches = fscanf(file, "%d/%d %d/%d/%d", &textureId[0], &normalId[0], &vertexId[1],
                              &textureId[1], &normalId[1]);

             // If 5 matches not found, try scanning first 2 face vertices without
             // texture format.
             if (matches != 5) {
                 matches = fscanf(file, "/%d %d//%d", &normalId[0], &vertexId[1], &normalId[1]);

                 // If 3 matches not found return with error.
                 if (matches != 3) {
                     LOG(WARNING) << "Face format not supported. Skipped.";
                     fgets(lineHeader, sizeof(lineHeader), file);
                     continue;
                 }

                 isTexturePresent = false;
             }

             // Copy first two face vertices to car vertices.
             std::array<CarVertex, kNumberOfVerticesPerFace> carVertices;
             CopyFaceToCarVertex(currentVertices, currentTextures, currentNormals, vertexId[0],
                                 textureId[0], normalId[0], &carVertices[0]);
             CopyFaceToCarVertex(currentVertices, currentTextures, currentNormals, vertexId[1],
                                 textureId[1], normalId[1], &carVertices[1]);

             // Add a triangle that the first two vertices make with every subsequent
             // face vertex 3 and onwards. Note this assumes the face is a convex
             // polygon.
             do {
                 if (isTexturePresent) {
                     matches = fscanf(file, " %d/%d/%d", &vertexId[2], &textureId[2], &normalId[2]);
                     // Warn if un-expected number of matches.
                     if (matches != 3 && matches != 0) {
                         LOG(WARNING) << "Face matches, expected 3, read: " << matches;
                         break;
                     }
                 } else {
                     // Warn if un-expected number of matches.
                     matches = fscanf(file, " %d//%d", &vertexId[2], &normalId[2]);
                     if (matches != 2 && matches != 0) {
                         LOG(WARNING) << "Face matches, expected 2, read: " << matches;
                         break;
                     }
                 }

                 if (matches == 0) {
                     break;
                 }

                 CopyFaceToCarVertex(currentVertices, currentTextures, currentNormals, vertexId[2],
                                     textureId[2], normalId[2], &carVertices[2]);

                 carPartsMap->at(currentGroupName).vertices.push_back(carVertices[0]);
                 carPartsMap->at(currentGroupName).vertices.push_back(carVertices[1]);
                 carPartsMap->at(currentGroupName).vertices.push_back(carVertices[2]);

                 carVertices[1] = carVertices[2];
             } while (true);

         } else {
             // LOG(WARNING) << "Unknown tag " << lineHeader << ". Skipped";
             fgets(lineHeader, sizeof(lineHeader), file);
             continue;
         }
     }

     fclose(file);
     return true;
 }

 }  // namespace implementation
 }  // namespace V1_0
 }  // namespace sv
 }  // namespace automotive
 }  // namespace hardware
 }  // namespace android
	/*
	* Copyright 2020 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#include "ObjReader.h"

	#include <array>
	#include <cstdio>
	#include <filesystem>
	#include <vector>

	#include "MtlReader.h"
	#include "core_lib.h"

	#include <android-base/logging.h>

	namespace android {
	namespace hardware {
	namespace automotive {
	namespace sv {
	namespace V1_0 {
	namespace implementation {

	using android_auto::surround_view::CarMaterial;
	using android_auto::surround_view::CarVertex;

	namespace {

	constexpr int kNumberOfVerticesPerFace = 3;
	constexpr int kNumberOfAxes = 3;
	constexpr int kCharBufferSize = 128;

	const std::array<float, 16> kMat4Identity = {
	/row 0/ 1, 0, 0, 0,
	/row 1/ 0, 1, 0, 0,
	/row 2/ 0, 0, 1, 0,
	/row 3/ 0, 0, 0, 1};

	// Copies face vertices parsed from obj to car vertices.
	void CopyFaceToCarVertex(const std::vector<std::array<float, kNumberOfAxes>>& currentVertices,
	const std::vector<std::array<float, kNumberOfAxes>>& currentTextures,
	const std::vector<std::array<float, kNumberOfAxes>>& currentNormals,
	int vertexId, int textureId, int normalId, CarVertex* carVertex) {
	std::memcpy(carVertex->pos.data(), currentVertices[vertexId - 1].data(),
	currentVertices[vertexId - 1].size() * sizeof(float));

	if (textureId != -1) {
	std::memcpy(carVertex->tex_coord.data(), currentTextures[textureId - 1].data(),
	2 * sizeof(float));
	// Set texture coodinates as invalid.
	carVertex->tex_coord = {-1.0, -1.0};
	}

	std::memcpy(carVertex->normal.data(), currentNormals[normalId - 1].data(),
	currentNormals[normalId - 1].size() * sizeof(float));
	}

	} // namespace

	bool ReadObjFromFile(const std::string& objFilename, std::map<std::string, CarPart>* carPartsMap) {
	return ReadObjFromFile(objFilename, ReadObjOptions(), carPartsMap);
	}

	bool ReadObjFromFile(const std::string& objFilename, const ReadObjOptions& option,
	std::map<std::string, CarPart>* carPartsMap) {
	FILE* file = fopen(objFilename.c_str(), "r");
	if (!file) {
	LOG(ERROR) << "Failed to open obj file: " << objFilename;
	return false;
	}

	for (int i = 0; i < kNumberOfAxes; ++i) {
	if (option.coordinateMapping[i] >= kNumberOfAxes \|\| option.coordinateMapping[i] < 0) {
	fclose(file);
	LOG(ERROR) << "coordinateMapping index must be less than 3 and greater or equal "
	"to 0.";
	return false;
	}
	}

	std::vector<std::array<float, kNumberOfAxes>> currentVertices;
	std::vector<std::array<float, kNumberOfAxes>> currentNormals;
	std::vector<std::array<float, kNumberOfAxes>> currentTextures;
	std::map<std::string, MtlConfigParams> mtlConfigParamsMap;
	std::string currentGroupName;
	MtlConfigParams currentMtlConfig;

	while (true) {
	char lineHeader[kCharBufferSize];
	// read the first word of the line
	int res = fscanf(file, "%s", lineHeader);

	if (res == EOF) {
	break; // EOF = End Of File. Quit the loop.
	}
	if (strcmp(lineHeader, "#") == 0) {
	fgets(lineHeader, sizeof(lineHeader), file);
	continue;
	}

	// TODO(b/156558814): add object type support.
	// TODO(b/156559272): add document for supported format.
	// Only single group per line is supported.
	if (strcmp(lineHeader, "g") == 0) {
	res = fscanf(file, "%s", lineHeader);
	currentGroupName = lineHeader;
	currentMtlConfig = MtlConfigParams();

	if (carPartsMap->find(currentGroupName) != carPartsMap->end()) {
	LOG(WARNING) << "Duplicate group name: " << currentGroupName
	<< ". using car part name as: " << currentGroupName << "_dup";
	currentGroupName.append("_dup");
	}
	carPartsMap->emplace(
	std::make_pair(currentGroupName,
	CarPart((std::vector<CarVertex>()), CarMaterial(), kMat4Identity,
	std::string(), std::vector<std::string>())));
	continue;
	}

	// no "g" case, assign it as default.
	if (currentGroupName.empty()) {
	currentGroupName = "default";
	currentMtlConfig = MtlConfigParams();
	carPartsMap->emplace(
	std::make_pair(currentGroupName,
	CarPart((std::vector<CarVertex>()), CarMaterial(), kMat4Identity,
	std::string(), std::vector<std::string>())));
	}

	if (strcmp(lineHeader, "usemtl") == 0) {
	res = fscanf(file, "%s", lineHeader);

	// If material name not found.
	if (mtlConfigParamsMap.find(lineHeader) == mtlConfigParamsMap.end()) {
	carPartsMap->at(currentGroupName).material = CarMaterial();
	LOG(ERROR) << "Material not found: $0" << lineHeader;
	return false;
	}

	currentMtlConfig = mtlConfigParamsMap[lineHeader];

	carPartsMap->at(currentGroupName).material.ka = {currentMtlConfig.ka[0],
	currentMtlConfig.ka[1],
	currentMtlConfig.ka[2]};

	carPartsMap->at(currentGroupName).material.kd = {currentMtlConfig.kd[0],
	currentMtlConfig.kd[1],
	currentMtlConfig.kd[2]};

	carPartsMap->at(currentGroupName).material.ks = {currentMtlConfig.ks[0],
	currentMtlConfig.ks[1],
	currentMtlConfig.ks[2]};

	carPartsMap->at(currentGroupName).material.d = currentMtlConfig.d;

	carPartsMap->at(currentGroupName).material.textures.clear();

	continue;
	}

	if (strcmp(lineHeader, "mtllib") == 0) {
	res = fscanf(file, "%s", lineHeader);
	mtlConfigParamsMap.clear();
	std::string mtlFilename;
	if (option.mtlFilename.empty()) {
	mtlFilename = objFilename.substr(0, objFilename.find_last_of("/"));
	mtlFilename.append("/");
	mtlFilename.append(lineHeader);
	} else {
	mtlFilename = option.mtlFilename;
	}
	if (!ReadMtlFromFile(mtlFilename, &mtlConfigParamsMap)) {
	LOG(ERROR) << "Parse MTL file " << mtlFilename << " failed.";
	return false;
	}
	continue;
	}

	if (strcmp(lineHeader, "v") == 0) {
	std::array<float, kNumberOfAxes> pos;
	fscanf(file, "%f %f %f\n", &pos[option.coordinateMapping[0]],
	&pos[option.coordinateMapping[1]], &pos[option.coordinateMapping[2]]);
	for (int i = 0; i < kNumberOfAxes; ++i) {
	pos[i] *= option.scales[i];
	pos[i] += option.offsets[i];
	}
	currentVertices.push_back(pos);
	} else if (strcmp(lineHeader, "vt") == 0) {
	std::array<float, kNumberOfAxes> texture;
	fscanf(file, "%f %f %f\n", &texture[0], &texture[1], &texture[2]);
	currentTextures.push_back(texture);
	} else if (strcmp(lineHeader, "vn") == 0) {
	std::array<float, kNumberOfAxes> normal;
	fscanf(file, "%f %f %f\n", &normal[option.coordinateMapping[0]],
	&normal[option.coordinateMapping[1]], &normal[option.coordinateMapping[2]]);
	currentNormals.push_back(normal);
	} else if (strcmp(lineHeader, "f") == 0) {
	int vertexId[kNumberOfVerticesPerFace];
	int textureId[kNumberOfVerticesPerFace] = {-1, -1, -1};
	int normalId[kNumberOfVerticesPerFace];

	// Face vertices supported formats:
	// With texture: pos/texture/normal
	// Without texture: pos//normal

	// Scan first vertex position.
	int matches = fscanf(file, "%d/", &vertexId[0]);

	if (matches != 1) {
	LOG(WARNING) << "Face index error. Skipped.";
	fgets(lineHeader, sizeof(lineHeader), file);
	continue;
	}

	// Try scanning first two face 2 vertices with texture format present.
	bool isTexturePresent = true;
	matches = fscanf(file, "%d/%d %d/%d/%d", &textureId[0], &normalId[0], &vertexId[1],
	&textureId[1], &normalId[1]);

	// If 5 matches not found, try scanning first 2 face vertices without
	// texture format.
	if (matches != 5) {
	matches = fscanf(file, "/%d %d//%d", &normalId[0], &vertexId[1], &normalId[1]);

	// If 3 matches not found return with error.
	if (matches != 3) {
	LOG(WARNING) << "Face format not supported. Skipped.";
	fgets(lineHeader, sizeof(lineHeader), file);
	continue;
	}

	isTexturePresent = false;
	}

	// Copy first two face vertices to car vertices.
	std::array<CarVertex, kNumberOfVerticesPerFace> carVertices;
	CopyFaceToCarVertex(currentVertices, currentTextures, currentNormals, vertexId[0],
	textureId[0], normalId[0], &carVertices[0]);
	CopyFaceToCarVertex(currentVertices, currentTextures, currentNormals, vertexId[1],
	textureId[1], normalId[1], &carVertices[1]);

	// Add a triangle that the first two vertices make with every subsequent
	// face vertex 3 and onwards. Note this assumes the face is a convex
	// polygon.
	do {
	if (isTexturePresent) {
	matches = fscanf(file, " %d/%d/%d", &vertexId[2], &textureId[2], &normalId[2]);
	// Warn if un-expected number of matches.
	if (matches != 3 && matches != 0) {
	LOG(WARNING) << "Face matches, expected 3, read: " << matches;
	break;
	}
	} else {
	// Warn if un-expected number of matches.
	matches = fscanf(file, " %d//%d", &vertexId[2], &normalId[2]);
	if (matches != 2 && matches != 0) {
	LOG(WARNING) << "Face matches, expected 2, read: " << matches;
	break;
	}
	}

	if (matches == 0) {
	break;
	}

	CopyFaceToCarVertex(currentVertices, currentTextures, currentNormals, vertexId[2],
	textureId[2], normalId[2], &carVertices[2]);

	carPartsMap->at(currentGroupName).vertices.push_back(carVertices[0]);
	carPartsMap->at(currentGroupName).vertices.push_back(carVertices[1]);
	carPartsMap->at(currentGroupName).vertices.push_back(carVertices[2]);

	carVertices[1] = carVertices[2];
	} while (true);

	} else {
	// LOG(WARNING) << "Unknown tag " << lineHeader << ". Skipped";
	fgets(lineHeader, sizeof(lineHeader), file);
	continue;
	}
	}

	fclose(file);
	return true;
	}

	} // namespace implementation
	} // namespace V1_0
	} // namespace sv
	} // namespace automotive
	} // namespace hardware
	} // namespace android