/* * stitcher.cpp - stitcher base * * Copyright (c) 2017 Intel Corporation * * 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. * * Author: Wind Yuan * Author: Yinhang Liu */ #include "stitcher.h" #include "xcam_utils.h" // angle to position, output range [-180, 180] #define OUT_WINDOWS_START 0.0f #define constraint_margin (2 * _alignment_x) #define XCAM_GL_RESTART_FIXED_INDEX 0xFFFF namespace XCam { static inline bool merge_neighbor_area ( const Stitcher::CopyArea ¤t, const Stitcher::CopyArea &next, Stitcher::CopyArea &merged) { if (current.in_idx == next.in_idx && current.in_area.pos_x + current.in_area.width == next.in_area.pos_x && current.out_area.pos_x + current.out_area.width == next.out_area.pos_x) { merged = current; merged.in_area.pos_x = current.in_area.pos_x; merged.in_area.width = current.in_area.width + next.in_area.width; merged.out_area.pos_x = current.out_area.pos_x; merged.out_area.width = current.out_area.width + next.out_area.width; return true; } return false; } static inline bool split_area_by_out ( const Stitcher::CopyArea &area, const uint32_t round_width, Stitcher::CopyArea &split_a, Stitcher::CopyArea &split_b) { XCAM_ASSERT (area.out_area.pos_x >= 0 && area.out_area.pos_x < (int32_t)round_width); XCAM_ASSERT (area.out_area.width > 0 && area.out_area.width < (int32_t)round_width); if (area.out_area.pos_x + area.out_area.width > (int32_t)round_width) { split_a = area; split_a.out_area.width = round_width - area.out_area.pos_x; split_a.in_area.width = split_a.out_area.width; split_b = area; split_b.in_area.pos_x = area.in_area.pos_x + split_a.in_area.width; split_b.in_area.width = area.in_area.width - split_a.in_area.width; split_b.out_area.pos_x = 0; split_b.out_area.width = split_b.in_area.width; XCAM_ASSERT (split_b.out_area.width == area.out_area.pos_x + area.out_area.width - (int32_t)round_width); return true; } XCAM_ASSERT (area.out_area.width == area.in_area.width); return false; } Stitcher::Stitcher (uint32_t align_x, uint32_t align_y) : _is_crop_set (false) , _alignment_x (align_x) , _alignment_y (align_y) , _output_width (0) , _output_height (0) , _out_start_angle (OUT_WINDOWS_START) , _camera_num (0) , _is_round_view_set (false) , _is_overlap_set (false) , _is_center_marked (false) { XCAM_ASSERT (align_x >= 1); XCAM_ASSERT (align_y >= 1); } Stitcher::~Stitcher () { } bool Stitcher::set_bowl_config (const BowlDataConfig &config) { _bowl_config = config; return true; } bool Stitcher::set_camera_num (uint32_t num) { XCAM_FAIL_RETURN ( ERROR, num <= XCAM_STITCH_MAX_CAMERAS, false, "stitcher: set camera count failed, num(%d) is larger than max value(%d)", num, XCAM_STITCH_MAX_CAMERAS); _camera_num = num; return true; } bool Stitcher::set_camera_info (uint32_t index, const CameraInfo &info) { XCAM_FAIL_RETURN ( ERROR, index < _camera_num, false, "stitcher: set camera info failed, index(%d) exceed max camera num(%d)", index, _camera_num); _camera_info[index] = info; return true; } bool Stitcher::set_crop_info (uint32_t index, const ImageCropInfo &info) { XCAM_FAIL_RETURN ( ERROR, index < _camera_num, false, "stitcher: set camera info failed, index(%d) exceed max camera num(%d)", index, _camera_num); _crop_info[index] = info; _is_crop_set = true; return true; } bool Stitcher::get_crop_info (uint32_t index, ImageCropInfo &info) const { XCAM_FAIL_RETURN ( ERROR, index < _camera_num, false, "stitcher: get crop info failed, index(%d) exceed camera num(%d)", index, _camera_num); info = _crop_info[index]; return true; } #if 0 bool Stitcher::set_overlap_info (uint32_t index, const ImageOverlapInfo &info) { XCAM_FAIL_RETURN ( ERROR, index < _camera_num, false, "stitcher: set overlap info failed, index(%d) exceed max camera num(%d)", index, _camera_num); _overlap_info[index] = info; _is_overlap_set = true; return true; } bool Stitcher::get_overlap_info (uint32_t index, ImageOverlapInfo &info) const { XCAM_FAIL_RETURN ( ERROR, index < _camera_num, false, "stitcher: get overlap info failed, index(%d) exceed camera num(%d)", index, _camera_num); info = _overlap_info[index]; return true; } #endif bool Stitcher::get_camera_info (uint32_t index, CameraInfo &info) const { XCAM_FAIL_RETURN ( ERROR, index < XCAM_STITCH_MAX_CAMERAS, false, "stitcher: get camera info failed, index(%d) exceed max camera value(%d)", index, XCAM_STITCH_MAX_CAMERAS); info = _camera_info[index]; return true; } XCamReturn Stitcher::estimate_round_slices () { if (_is_round_view_set) return XCAM_RETURN_NO_ERROR; XCAM_FAIL_RETURN ( ERROR, _camera_num && _camera_num < XCAM_STITCH_MAX_CAMERAS, XCAM_RETURN_ERROR_PARAM, "stitcher: camera num was not set, or camera num(%d) exceed max camera value(%d)", _camera_num, XCAM_STITCH_MAX_CAMERAS); for (uint32_t i = 0; i < _camera_num; ++i) { CameraInfo &cam_info = _camera_info[i]; RoundViewSlice &view_slice = _round_view_slices[i]; view_slice.width = cam_info.angle_range / 360.0f * (float)_output_width; view_slice.width = XCAM_ALIGN_UP (view_slice.width, _alignment_x); view_slice.height = _output_height; view_slice.hori_angle_range = view_slice.width * 360.0f / (float)_output_width; uint32_t aligned_start = format_angle (cam_info.round_angle_start) / 360.0f * (float)_output_width; aligned_start = XCAM_ALIGN_AROUND (aligned_start, _alignment_x); if (_output_width <= constraint_margin + aligned_start || aligned_start <= constraint_margin) aligned_start = 0; view_slice.hori_angle_start = format_angle((float)aligned_start / (float)_output_width * 360.0f); if (XCAM_DOUBLE_EQUAL_AROUND (view_slice.hori_angle_start, 0.0001f)) view_slice.hori_angle_start = 0.0f; cam_info.round_angle_start = view_slice.hori_angle_start; cam_info.angle_range = view_slice.hori_angle_range; } _is_round_view_set = true; return XCAM_RETURN_NO_ERROR; } XCamReturn Stitcher::estimate_coarse_crops () { if (_is_crop_set) return XCAM_RETURN_NO_ERROR; XCAM_FAIL_RETURN ( ERROR, _camera_num > 0 && _is_round_view_set, XCAM_RETURN_ERROR_ORDER, "stitcher mark_centers failed, need set camera info and round_slices first"); for (uint32_t i = 0; i < _camera_num; ++i) { _crop_info[i].left = 0; _crop_info[i].right = 0; _crop_info[i].top = 0; _crop_info[i].bottom = 0; } _is_crop_set = true; return XCAM_RETURN_NO_ERROR; } // after crop done XCamReturn Stitcher::mark_centers () { if (_is_center_marked) return XCAM_RETURN_NO_ERROR; XCAM_FAIL_RETURN ( ERROR, _camera_num > 0 && _is_round_view_set, XCAM_RETURN_ERROR_ORDER, "stitcher mark_centers failed, need set camera info and round_view slices first"); for (uint32_t i = 0; i < _camera_num; ++i) { const RoundViewSlice &slice = _round_view_slices[i]; //calcuate final output postion float center_angle = i * 360.0f / _camera_num; uint32_t out_pos = format_angle (center_angle - _out_start_angle) / 360.0f * _output_width; XCAM_ASSERT (out_pos < _output_width); if (_output_width <= constraint_margin + out_pos || out_pos <= constraint_margin) out_pos = 0; // get slice center angle center_angle = XCAM_ALIGN_AROUND (out_pos, _alignment_x) / (float)_output_width * 360.0f - _out_start_angle; center_angle = format_angle (center_angle); float center_in_slice = center_angle - slice.hori_angle_start; center_in_slice = format_angle (center_in_slice); XCAM_FAIL_RETURN ( ERROR, center_in_slice < slice.hori_angle_range, XCAM_RETURN_ERROR_PARAM, "stitcher mark center failed, slice:%d calculated center-angle:%.2f is out of slice angle(start:%.2f, range:%.2f)", center_angle, slice.hori_angle_start, slice.hori_angle_range); uint32_t slice_pos = (uint32_t)(center_in_slice / slice.hori_angle_range * slice.width); slice_pos = XCAM_ALIGN_AROUND (slice_pos, _alignment_x); XCAM_ASSERT (slice_pos > _crop_info[i].left && slice_pos < slice.width - _crop_info[i].right); _center_marks[i].slice_center_x = slice_pos; _center_marks[i].out_center_x = out_pos; } _is_center_marked = true; return XCAM_RETURN_NO_ERROR; } XCamReturn Stitcher::estimate_overlap () { if (_is_overlap_set) return XCAM_RETURN_NO_ERROR; XCAM_FAIL_RETURN ( ERROR, _is_round_view_set && _is_crop_set && _is_center_marked, XCAM_RETURN_ERROR_ORDER, "stitcher estimate_coarse_seam failed, need set round_view slices, crop info and mark centers first"); for (uint32_t idx = 0; idx < _camera_num; ++idx) { uint32_t next_idx = (idx + 1) % _camera_num; const RoundViewSlice &left = _round_view_slices[idx]; const RoundViewSlice &right = _round_view_slices[next_idx]; const CenterMark &left_center = _center_marks[idx]; const CenterMark &right_center = _center_marks[next_idx]; const ImageCropInfo &left_img_crop = _crop_info[idx]; const ImageCropInfo &right_img_crop = _crop_info[next_idx]; #if 0 XCAM_FAIL_RETURN ( ERROR, (format_angle (right.hori_angle_start - left.hori_angle_start) < left.hori_angle_range) XCAM_RETURN_ERROR_UNKNOWN, "stitcher estimate_coarse_seam failed and there is no seam between slice %d and slice %d", idx, next_idx); float seam_angle_start = right.hori_angle_start; float seam_angle_range = format_angle (left.hori_angle_start + left.hori_angle_range - right.hori_angle_start); XCAM_FAIL_RETURN ( ERROR, seam_angle_range < right.hori_angle_range, XCAM_RETURN_ERROR_UNKNOWN, "stitcher estimate_coarse_seam failed and left slice(%d)over covered right slice(%d)", idx, next_idx); XCAM_ASSERT (!XCAM_DOUBLE_EQUAL_AROUND (left.hori_angle_range, 0.0f)); XCAM_ASSERT (!XCAM_DOUBLE_EQUAL_AROUND (right.hori_angle_range, 0.0f)); #endif uint32_t out_right_center_x = right_center.out_center_x; if (out_right_center_x == 0) out_right_center_x = _output_width; Rect valid_left_img, valid_right_img; valid_left_img.pos_x = left_center.slice_center_x; valid_left_img.width = left.width - left_img_crop.right - valid_left_img.pos_x; valid_left_img.pos_y = left_img_crop.top; valid_left_img.height = left.height - left_img_crop.top - left_img_crop.bottom; valid_right_img.width = right_center.slice_center_x - right_img_crop.left; valid_right_img.pos_x = right_center.slice_center_x - valid_right_img.width; valid_right_img.pos_y = right_img_crop.top; valid_right_img.height = right.height - right_img_crop.top - right_img_crop.bottom; uint32_t merge_width = out_right_center_x - left_center.out_center_x; XCAM_FAIL_RETURN ( ERROR, valid_left_img.width + valid_right_img.width > (int32_t)merge_width, XCAM_RETURN_ERROR_UNKNOWN, "stitcher estimate_overlap failed and there is no overlap area between slice %d and slice %d", idx, next_idx); uint32_t overlap_width = valid_left_img.width + valid_right_img.width - merge_width; Rect left_img_overlap, right_img_overlap; left_img_overlap.pos_x = valid_left_img.pos_x + valid_left_img.width - overlap_width; left_img_overlap.width = overlap_width; left_img_overlap.pos_y = valid_left_img.pos_y; left_img_overlap.height = valid_left_img.height; XCAM_ASSERT (left_img_overlap.pos_x >= (int32_t)left_center.slice_center_x && left_img_overlap.pos_x < (int32_t)left.width); right_img_overlap.pos_x = valid_right_img.pos_x; right_img_overlap.width = overlap_width; right_img_overlap.pos_y = valid_right_img.pos_y; right_img_overlap.height = valid_right_img.height; XCAM_ASSERT (right_img_overlap.pos_x >= (int32_t)right_img_crop.left && right_img_overlap.pos_x < (int32_t)right_center.slice_center_x); Rect out_overlap; out_overlap.pos_x = left_center.out_center_x + valid_left_img.width - overlap_width; out_overlap.width = overlap_width; // out_overlap.pos_y/height not useful by now out_overlap.pos_y = valid_left_img.pos_y; out_overlap.height = valid_left_img.height; #if 0 left_img_seam.pos_x = left.width * format_angle (seam_angle_start - left.hori_angle_start) / left.hori_angle_range; left_img_seam.pos_y = _crop_info[idx].top; left_img_seam.width = left.width * seam_angle_range / left.hori_angle_range; left_img_seam.height = left.height - _crop_info[idx].top - _crop_info[idx].bottom; //consider crop XCAM_ASSERT (left_img_seam.pos_x < left.width - _crop_info[idx].right); if (left_img_seam.pos_x + left_img_seam.width > left.width - _crop_info[idx].right) left_img_seam.width = left.width - _crop_info[idx].right; right_img_seam.pos_x = 0; right_img_seam.pos_y = _crop_info[next_idx].top; right_img_seam.width = right.width * (seam_angle_range / right.hori_angle_range); right_img_seam.height = right.height - _crop_info[next_idx].top - _crop_info[next_idx].bottom; //consider crop XCAM_ASSERT (right_img_seam.pos_x + right_img_seam.width > _crop_info[next_idx].left); if (_crop_info[next_idx].left) { right_img_seam.pos_x = _crop_info[next_idx].left; right_img_seam.width -= _crop_info[next_idx].left; left_img_seam.pos_x += _crop_info[next_idx].left; left_img_seam.width -= _crop_info[next_idx].left; } XCAM_ASSERT (abs (left_img_seam.width - right_img_seam.width) < 16); left_img_seam.pos_x = XCAM_ALIGN_DOWN (left_img_seam.pos_x, _alignment_x); right_img_seam.pos_x = XCAM_ALIGN_DOWN (right_img_seam.pos_x, _alignment_x); //find max seam width uint32_t seam_width, seam_height; seam_width = XCAM_MAX (left_img_seam.width, right_img_seam.width); if (left_img_seam.pos_x + seam_width > left.width) seam_width = left.width - left_img_seam.pos_x; if (right_img_seam.pos_x + seam_width > right.width) seam_width = right.width - right_img_seam.pos_x; XCAM_FAIL_RETURN ( ERROR, seam_width >= XCAM_STITCH_MIN_SEAM_WIDTH, XCAM_RETURN_ERROR_UNKNOWN, "stitcher estimate_coarse_seam failed, the seam(w:%d) is very narrow between(slice %d and %d)", seam_width, idx, next_idx); left_img_seam.width = right_img_seam.width = XCAM_ALIGN_DOWN (seam_width, _alignment_x); // min height uint32_t top = XCAM_MAX (left_img_seam.pos_y, right_img_seam.pos_y); uint32_t bottom0 = left_img_seam.pos_y + left_img_seam.height; uint32_t bottom1 = right_img_seam.pos_y + right_img_seam.height; uint32_t bottom = XCAM_MIN (bottom0, bottom1); top = XCAM_ALIGN_UP (top, _alignment_y); left_img_seam.pos_y = right_img_seam.pos_y = top; left_img_seam.height = right_img_seam.height = XCAM_ALIGN_DOWN (bottom - top, _alignment_y); #endif // set overlap info _overlap_info[idx].left = left_img_overlap; _overlap_info[idx].right = right_img_overlap; _overlap_info[idx].out_area = out_overlap; } _is_overlap_set = true; return XCAM_RETURN_NO_ERROR; } XCamReturn Stitcher::update_copy_areas () { XCAM_FAIL_RETURN ( ERROR, _camera_num > 1 && _is_round_view_set && _is_crop_set && _is_overlap_set, XCAM_RETURN_ERROR_ORDER, "stitcher update_copy_areas failed, check orders, need" "camera_info, round_view slices, crop_info and overlap_info set first."); CopyAreaArray tmp_areas; uint32_t i = 0; uint32_t next_i = 0; for (i = 0; i < _camera_num; ++i) { next_i = (i + 1 ) % _camera_num; const CenterMark &mark_left = _center_marks[i]; const CenterMark &mark_right = _center_marks[next_i]; const ImageOverlapInfo &overlap = _overlap_info[i]; CopyArea split_a, split_b; CopyArea left; left.in_idx = i; left.in_area.pos_x = mark_left.slice_center_x; left.in_area.width = overlap.left.pos_x - left.in_area.pos_x; XCAM_ASSERT (left.in_area.width > 0); left.in_area.pos_y = _crop_info[i].top; left.in_area.height = _round_view_slices[i].height - _crop_info[i].top - _crop_info[i].bottom; XCAM_ASSERT (left.in_area.height > 0); left.out_area.pos_x = mark_left.out_center_x; left.out_area.width = left.in_area.width; left.out_area.pos_y = 0; left.out_area.height = left.in_area.height; if (split_area_by_out (left, _output_width, split_a, split_b)) { tmp_areas.push_back (split_a); tmp_areas.push_back (split_b); } else { tmp_areas.push_back (left); } CopyArea right; right.in_idx = next_i; right.in_area.pos_x = _overlap_info[i].right.pos_x + _overlap_info[i].right.width; right.in_area.width = (int32_t)mark_right.slice_center_x - right.in_area.pos_x; XCAM_ASSERT (right.in_area.width > 0); right.in_area.pos_y = _crop_info[next_i].top; right.in_area.height = _round_view_slices[next_i].height - _crop_info[next_i].top - _crop_info[next_i].bottom; XCAM_ASSERT (right.in_area.height > 0); uint32_t out_right_center_x = mark_right.out_center_x; if (out_right_center_x == 0) out_right_center_x = _output_width; right.out_area.width = right.in_area.width; right.out_area.pos_x = out_right_center_x - right.out_area.width; right.out_area.pos_y = 0; right.out_area.height = right.in_area.height; if (split_area_by_out (right, _output_width, split_a, split_b)) { tmp_areas.push_back (split_a); tmp_areas.push_back (split_b); } else { tmp_areas.push_back (right); } } XCAM_ASSERT (tmp_areas.size () > _camera_num && _camera_num >= 2); CopyArea merged; int32_t start = 0; int32_t end = tmp_areas.size () - 1; if (tmp_areas.size () > 2) { const CopyArea &first = tmp_areas[0]; const CopyArea &last = tmp_areas[end]; // merge first and last if (merge_neighbor_area (last, first, merged)) { _copy_areas.push_back (merged); ++start; --end; } } // merge areas for (i = (uint32_t)start; (int32_t)i <= end; ) { const CopyArea ¤t = tmp_areas[i]; if (i == (uint32_t)end) { _copy_areas.push_back (current); break; } const CopyArea &next = tmp_areas[i + 1]; if (merge_neighbor_area (current, next, merged)) { _copy_areas.push_back (merged); i += 2; } else { _copy_areas.push_back (current); i += 1; } } XCAM_ASSERT (_copy_areas.size() >= _camera_num); return XCAM_RETURN_NO_ERROR; } BowlModel::BowlModel (const BowlDataConfig &config, const uint32_t image_width, const uint32_t image_height) : _config (config) , _bowl_img_width (image_width) , _bowl_img_height (image_height) { //max area => x/a = y/b XCAM_ASSERT (fabs(_config.center_z) < _config.c); float mid = sqrt ((1.0f - _config.center_z * _config.center_z / (_config.c * _config.c)) / 2.0f); _max_topview_length_mm = mid * _config.a * 2.0f; _max_topview_width_mm = mid * _config.b * 2.0f; } bool BowlModel::get_max_topview_area_mm (float &length_mm, float &width_mm) { if (_max_topview_width_mm <= 0.0f || _max_topview_length_mm <= 0.0f) return false; length_mm = _max_topview_length_mm; width_mm = _max_topview_width_mm; return true; } bool BowlModel::get_topview_rect_map ( PointMap &texture_points, uint32_t res_width, uint32_t res_height, float length_mm, float width_mm) { if (XCAM_DOUBLE_EQUAL_AROUND (length_mm, 0.0f) || XCAM_DOUBLE_EQUAL_AROUND (width_mm, 0.0f)) { get_max_topview_area_mm (length_mm, width_mm); } XCAM_FAIL_RETURN ( ERROR, length_mm * length_mm / (_config.a * _config.a) / 4.0f + width_mm * width_mm / (_config.b * _config.b) / 4.0f + _config.center_z * _config.center_z / (_config.c * _config.c) <= 1.0f + 0.001f, false, "bowl model topview input area(L:%.2fmm, W:%.2fmm) is larger than max area", length_mm, width_mm); float center_pos_x = res_width / 2.0f; float center_pos_y = res_height / 2.0f; float mm_per_pixel_x = length_mm / res_width; float mm_per_pixel_y = width_mm / res_height; texture_points.resize (res_width * res_height); for(uint32_t row = 0; row < res_height; row++) { for(uint32_t col = 0; col < res_width; col++) { PointFloat3 world_pos ( (col - center_pos_x) * mm_per_pixel_x, (center_pos_y - row) * mm_per_pixel_y, 0.0f); PointFloat2 texture_pos = bowl_view_coords_to_image ( _config, world_pos, _bowl_img_width, _bowl_img_height); texture_points [res_width * row + col] = texture_pos; } } return true; } bool BowlModel::get_stitch_image_vertex_model ( VertexMap &vertices, PointMap &texture_points, IndexVector &indeices, uint32_t res_width, uint32_t res_height, float vertex_height) { vertices.reserve (2 * (res_width + 1) * (res_height + 1)); texture_points.reserve (2 * (res_width + 1) * (res_height + 1)); indeices.reserve (2 * (res_width + 1) * (res_height + 1) + (res_height + 1)); float step_x = (float)_bowl_img_width / res_width; float step_y = vertex_height / res_height; float offset_y = (float)_bowl_img_height - vertex_height; int32_t indicator = 0; for (uint32_t row = 0; row < res_height - 1; row++) { PointFloat2 texture_pos0; texture_pos0.y = row * step_y + offset_y; PointFloat2 texture_pos1; texture_pos1.y = (row + 1) * step_y + offset_y; for (uint32_t col = 0; col <= res_width; col++) { texture_pos0.x = col * step_x; texture_pos1.x = col * step_x; PointFloat3 world_pos0 = bowl_view_image_to_world ( _config, _bowl_img_width, _bowl_img_height, texture_pos0); vertices.push_back (PointFloat3(world_pos0.x / _config.a, world_pos0.y / _config.b, world_pos0.z / _config.c)); indeices.push_back (indicator++); texture_points.push_back (PointFloat2(texture_pos0.x / _bowl_img_width, (_bowl_img_height - texture_pos0.y) / _bowl_img_height)); PointFloat3 world_pos1 = bowl_view_image_to_world ( _config, _bowl_img_width, _bowl_img_height, texture_pos1); vertices.push_back (PointFloat3(world_pos1.x / _config.a, world_pos1.y / _config.b, world_pos1.z / _config.c)); indeices.push_back (indicator++); texture_points.push_back (PointFloat2(texture_pos1.x / _bowl_img_width, (_bowl_img_height - texture_pos1.y) / _bowl_img_height)); } } return true; } bool BowlModel::get_bowlview_vertex_model ( VertexMap &vertices, PointMap &texture_points, IndexVector &indeices, uint32_t res_width, uint32_t res_height) { return get_stitch_image_vertex_model (vertices, texture_points, indeices, res_width, res_height, (float)_bowl_img_height); } bool BowlModel::get_topview_vertex_model ( VertexMap &vertices, PointMap &texture_points, IndexVector &indeices, uint32_t res_width, uint32_t res_height) { float wall_image_height = _config.wall_height / (float)(_config.wall_height + _config.ground_length) * (float)_bowl_img_height; float ground_image_height = (float)_bowl_img_height - wall_image_height; return get_stitch_image_vertex_model (vertices, texture_points, indeices, res_width, res_height, ground_image_height); } }