static bool render_box_ (ImageBuf &dst, array_view<const float> color, ROI roi=ROI(), int nthreads=1) { if (nthreads != 1 && roi.npixels() >= 1000) { // Lots of pixels and request for multi threads? Parallelize. ImageBufAlgo::parallel_image ( OIIO::bind(render_box_<T>, OIIO::ref(dst), color, _1 /*roi*/, 1 /*nthreads*/), roi, nthreads); return true; } // Serial case float alpha = 1.0f; if (dst.spec().alpha_channel >= 0 && dst.spec().alpha_channel < int(color.size())) alpha = color[dst.spec().alpha_channel]; else if (int(color.size()) == roi.chend+1) alpha = color[roi.chend]; if (alpha == 1.0f) { for (ImageBuf::Iterator<T> r (dst, roi); !r.done(); ++r) for (int c = roi.chbegin; c < roi.chend; ++c) r[c] = color[c]; } else { for (ImageBuf::Iterator<T> r (dst, roi); !r.done(); ++r) for (int c = roi.chbegin; c < roi.chend; ++c) r[c] = color[c] + r[c] * (1.0f-alpha); // "over" } return true; }
bool ImageBufAlgo::render_line (ImageBuf &dst, int x1, int y1, int x2, int y2, array_view<const float> color, bool skip_first_point, ROI roi, int nthreads) { if (! IBAprep (roi, &dst)) return false; if (int(color.size()) < roi.chend) { dst.error ("Not enough channels for the color (needed %d)", roi.chend); return false; // Not enough color channels specified } const ImageSpec &spec (dst.spec()); // Alpha: if the image's spec designates an alpha channel, use it if // it's within the range specified by color. Otherwise, if color // includes more values than the highest channel roi says we should // modify, assume the first extra value is alpha. If all else fails, // make the line opaque (alpha=1.0). float alpha = 1.0f; if (spec.alpha_channel >= 0 && spec.alpha_channel < int(color.size())) alpha = color[spec.alpha_channel]; else if (int(color.size()) == roi.chend+1) alpha = color[roi.chend]; bool ok; OIIO_DISPATCH_TYPES (ok, "render_line", render_line_, dst.spec().format, dst, x1, y1, x2, y2, color, alpha, skip_first_point, roi, nthreads); return ok; }
bool DetectTga(array_view<uint8_t> data, ImageFileInfo& info) { if (data.size() < sizeof(TgaHeader)) { return false; } auto header = reinterpret_cast<const TgaHeader*>(data.data()); if (header->colorMapType != TgaColorMapType::TrueColor) { return false; // We don't supported index TGA } if (header->dataType != TgaDataType::UncompressedRgb) { return false; // We only support uncompressed RGB } if (header->bpp != 24 && header->bpp != 32) { return false; // We only support 24 or 32 bit TGAs } info.width = header->width; info.height = header->height; info.hasAlpha = (header->bpp == 32); info.format = ImageFileFormat::TGA; return true; }
ImageFileInfo DetectImageFormat(array_view<uint8_t> data) { ImageFileInfo info; stbi__context ctx; stbi__start_mem(&ctx, &data[0], data.bytes()); int comp; if (stbi__bmp_info(&ctx, &info.width, &info.height, &comp)) { info.hasAlpha = (comp == 4); info.format = ImageFileFormat::BMP; return info; } TjDecompressHandle handle; if (tjDecompressHeader(handle, &data[0], data.bytes(), &info.width, &info.height) == 0) { info.hasAlpha = false; info.format = ImageFileFormat::JPEG; return info; } if (DetectTga(data, info)) { return info; } // Not a very good heuristic if (data.size() == 256 * 256) { info.width = 256; info.height = 256; info.hasAlpha = true; info.format = ImageFileFormat::FNTART; return info; } return info; }
void ClipFacade::SetFeatureMatrix(array_view<ArmatureFrame> frames, double duration, bool cyclic) { assert(m_pParts != nullptr && m_flag != NotInitialize); m_inited = false; auto& parts = *m_pParts; int fLength = m_partDim.back() + m_partSt.back(); auto dt = duration / (frames.size() - (size_t)(!cyclic)); bool useVelocity = dt > 0; m_X.resize(frames.size(), fLength); for (int f = 0; f < frames.size(); f++) { auto& lastFrame = frames[f>0?f-1:frames.size()-1]; auto& frame = frames[f]; for (int i = 0; i < parts.size(); i++) { auto part = parts[i]; auto fv = m_X.block(f, m_partSt[i], 1, m_partDim[i]); if (!useVelocity) fv = m_pFeature->Get(*part, frame); else fv = m_pFeature->Get(*part, frame, lastFrame, dt); } } }
std::unique_ptr<uint8_t[]> DecodeTga(array_view<uint8_t> data) { if (data.size() < sizeof(TgaHeader)) { throw TempleException("Not enough data for TGA header"); } auto header = reinterpret_cast<const TgaHeader*>(data.data()); if (header->colorMapType != TgaColorMapType::TrueColor) { throw TempleException("Only true color TGA images are supported."); } if (header->dataType != TgaDataType::UncompressedRgb) { throw TempleException("Only uncompressed RGB TGA images are supported."); } if (header->bpp != 24 && header->bpp != 32) { throw TempleException("Only uncompressed RGB 24-bpp or 32-bpp TGA images are supported."); } auto result(std::make_unique<uint8_t[]>(header->width * header->height * 4)); auto dest = result.get(); // Points to the start of the TGA image data auto srcStart = data.data() + sizeof(TgaHeader) + header->imageIdLength; auto srcSize = data.size() - sizeof(TgaHeader) - header->imageIdLength; if (header->bpp == 24) { auto srcPitch = header->width * 3; Expects((int) srcSize >= header->height * srcPitch); for (int y = 0; y < header->height; ++y) { auto src = srcStart + (header->height - y - 1) * srcPitch; for (int x = 0; x < header->width; ++x) { *dest++ = *src++; *dest++ = *src++; *dest++ = *src++; *dest++ = 0xFF; // Fixed alpha } } } else { auto srcPitch = header->width * 4; Expects((int) srcSize >= header->height * srcPitch); for (int y = 0; y < header->height; ++y) { auto src = srcStart + (header->height - y - 1) * srcPitch; for (int x = 0; x < header->width; ++x) { *dest++ = *src++; *dest++ = *src++; *dest++ = *src++; *dest++ = *src++; } } } return result; }
inline std::string key_qvalue_pairs(array_view<kv_pair> pairs) { std::string buffer; // Ensure string is large enough for our use, to avoid useless internal resize size_t maj = std::accumulate(pairs.begin(), pairs.end(), size_t{0}, [](size_t acc, kv_pair p){return acc + p.key.size()+p.value.size()+8;}); // reserve some space for 8 quoted chars inside value // if there is more string is on it's own and will spend slightly more time buffer.reserve(maj+8); return key_qvalue_pairs(buffer, pairs); }
std::unique_ptr<uint8_t[]> DecodeJpeg(const array_view<uint8_t> data) { TjDecompressHandle handle; int w, h; tjDecompressHeader(handle, &data[0], data.bytes(), &w, &h); std::unique_ptr<uint8_t[]> result(new uint8_t[w * h * 4]); auto status = tjDecompress2(handle, &data[0], data.bytes(), &result[0], w, w * 4, h, TJPF_BGRX, 0); if (status != 0) { throw TempleException("Unable to decompress jpeg image: {}", tjGetErrorStr()); } return result; }
bool ImageBufAlgo::render_box (ImageBuf &dst, int x1, int y1, int x2, int y2, array_view<const float> color, bool fill, ROI roi, int nthreads) { if (! IBAprep (roi, &dst)) return false; if (int(color.size()) < roi.chend) { dst.error ("Not enough channels for the color (needed %d)", roi.chend); return false; // Not enough color channels specified } // Filled case if (fill) { roi = roi_intersection (roi, ROI(x1, x2+1, y1, y2+1, 0, 1, 0, roi.chend)); bool ok; OIIO_DISPATCH_TYPES (ok, "render_box", render_box_, dst.spec().format, dst, color, roi, nthreads); return ok; } // Unfilled case: use IBA::render_line return ImageBufAlgo::render_line (dst, x1, y1, x2, y1, color,true, roi, nthreads) && ImageBufAlgo::render_line (dst, x2, y1, x2, y2, color,true, roi, nthreads) && ImageBufAlgo::render_line (dst, x2, y2, x1, y2, color,true, roi, nthreads) && ImageBufAlgo::render_line (dst, x1, y2, x1, y1, color,true, roi, nthreads); }
DecodedImage DecodeImage(const array_view<uint8_t> data) { DecodedImage result; result.info = DetectImageFormat(data); stbi__context ctx; stbi__start_mem(&ctx, &data[0], data.bytes()); int w, h, comp; switch (result.info.format) { case ImageFileFormat::BMP: result.data.reset(stbi__bmp_load(&ctx, &w, &h, &comp, 4)); break; case ImageFileFormat::JPEG: result.data = DecodeJpeg(data); break; case ImageFileFormat::TGA: result.data = DecodeTga(data); break; case ImageFileFormat::FNTART: return DecodeFontArt(data); default: case ImageFileFormat::Unknown: throw TempleException("Unrecognized image format."); } return result; }
bool operator == (const array_view & other) const noexcept { // Pointers to same memory (or both null). if (data() == other.data()) { return true; } // Different sizes, whole sequence can't be identical. if (size() != other.size()) { return false; } // Compare each element: return std::equal(begin(), end(), other.begin()); }
void AbsoluteLnQuaternionDecoder::Decode(array_view<DirectX::Quaternion> rots, const VectorType & x) { int n = rots.size(); Eigen::Vector4f qs; XMVECTOR q; qs.setZero(); for (int i = 0; i < n; i++) { qs.segment<3>(0) = x.segment<3>(i * 3).cast<float>(); q = XMLoadFloat4A(qs.data()); q = XMQuaternionExp(q); // revert the log map XMStoreA(rots[i], q); } }
void AbsoluteEulerAngleDecoder::Decode(array_view<DirectX::Quaternion> rots, const VectorType & y) { int n = rots.size(); Eigen::Vector4f qs; XMVECTOR q; qs.setZero(); for (int i = 0; i < n; i++) { qs.segment<3>(0) = y.segment<3>(i * 3).cast<float>(); q = XMLoadFloat4A(qs.data()); q = XMQuaternionRotationRollPitchYawFromVector(q); // revert the log map XMStoreA(rots[i], q); } }
void AbsoluteEulerAngleDecoder::Encode(array_view<const DirectX::Quaternion> rots, VectorType & x) { int n = rots.size(); Eigen::Vector4f qs; XMVECTOR q; qs.setZero(); x.resize(n * 3); for (int i = 0; i < n; i++) { q = XMLoad(rots[i]); q = XMQuaternionEulerAngleYawPitchRoll(q); // Decompsoe in to euler angle XMStoreFloat4(qs.data(), q); x.segment<3>(i * 3) = qs.head<3>(); } }
void DeepData::set_all_samples (array_view<const unsigned int> samples) { if (samples.size() != size_t(m_npixels)) return; ASSERT (m_impl); if (m_impl->m_allocated) { // Data already allocated: set pixels individually for (int p = 0; p < m_npixels; ++p) set_samples (p, int(samples[p])); } else { // Data not yet allocated: copy in one shot m_impl->m_nsamples.assign (&samples[0], &samples[m_npixels]); m_impl->m_capacity.assign (&samples[0], &samples[m_npixels]); } }
void RelativeEulerAngleDecoder::Decode(array_view<DirectX::Quaternion> rots, const VectorType & x) { int n = rots.size(); Eigen::Vector4f qs; XMVECTOR q, qb; qs.setZero(); for (int i = 0; i < n; i++) { qs.segment<3>(0) = x.segment<3>(i * 3).cast<float>(); q = XMLoadFloat4A(qs.data()); q = XMQuaternionRotationRollPitchYawFromVector(q); // revert the log map qb = XMLoadA(bases[i]); q = XMQuaternionMultiply(qb, q); XMStoreA(rots[i], q); } }
wal_bitmap xtk::wal_decode (const array_view<std::uint8_t>& data, const array_view<bitmap::value_type>& colormap) { const auto& header = *(const wal_header*)data.data (); auto _bitmap = wal_bitmap { make_bitmap_level (data, colormap, 0, header), make_bitmap_level (data, colormap, 1, header), make_bitmap_level (data, colormap, 2, header), make_bitmap_level (data, colormap, 3, header), std::string (header.name, strnlen (header.name, sizeof (header.name))), std::string (header.next_name, strnlen (header.next_name, sizeof (header.next_name))) }; return std::move (_bitmap); }
static bitmap make_bitmap_level (const array_view<std::uint8_t>& data, const array_view<bitmap::value_type>& colormap, int level, const wal_header& header) { auto div1 = 1 << level; auto width = header.width / div1 ; auto height = header.height / div1 ; auto buffer = std::make_unique<bitmap::value_type[]> (width*height); auto data_view = array_view<std::uint8_t> { data.begin () + header.offset [level], data.begin () + header.offset [level] + width*height }; for (auto i = 0; i < width*height; ++i) { buffer [i] = colormap [data_view [i]]; } return bitmap (std::move (buffer), width, height); };
StaticArmature::StaticArmature(array_view<JointBasicData> data) { size_t jointCount = data.size(); m_joints.resize(jointCount); for (size_t i = 0; i < jointCount; i++) { m_joints[i].SetID(i); int parentID = data[i].ParentID; if (parentID != i &&parentID >= 0) { m_joints[parentID].append_children_back(&m_joints[i]); } else { m_rootIdx = i; } } CaculateTopologyOrder(); }
DecodedImage DecodeFontArt(const array_view<uint8_t> data) { // 256x256 image with 8bit alpha Expects(data.size() == 256 * 256); DecodedImage result; result.info.width = 256; result.info.height = 256; result.info.format = ImageFileFormat::FNTART; result.info.hasAlpha = true; result.data = std::make_unique<uint8_t[]>(256 * 256 * 4); auto *dest = result.data.get(); for (auto alpha : data) { *dest++ = 0xFF; *dest++ = 0xFF; *dest++ = 0xFF; *dest++ = alpha; } return result; }
/// Swap friend void swap( array_view & A, array_view & B) { A.swap_me(B);}
array_view(array_view<ConvertibleType> other) noexcept : m_pointer{ other.data() } , m_size_in_items{ other.size() } { }
bool operator > (const array_view & other) const noexcept { return data() > other.data(); }
friend view_type c_ordered_transposed_view(array_view const& a) { return transposed_view(a, a.indexmap().get_memory_layout().get_memory_positions()); }
/// Copy constructor array_view(array_view const & X): BaseType(X.indexmap(),X.storage()) {}
array_view(array_view<value_type, OtherLength> other) : Length(other.length()) , m_data(other.data()) { }
/// Copy constructor array_view(array_view const& X) : IMPL_TYPE(X.indexmap(), X.storage()) {}
inline constexpr bool operator==(array_view<T1> const& lhs, T2 const (& rhs)[N]) { return detail::operator_equal_impl(lhs, lhs.length(), rhs, N); }
array_view<V, sizeof...(I), Opt,indexmaps::mem_layout::c_order(sizeof...(I))> reinterpret_array_view (array_view<V,R,Opt,To,B> const & a, I ... index) { if (!has_contiguous_data(a)) TRIQS_RUNTIME_ERROR << "reinterpretation failure : data of the view are not contiguous"; return { {make_shape(index...)}, a.storage() }; }
inline constexpr bool operator==(array_view<T> const& lhs, Array const& rhs) { return detail::operator_equal_impl(lhs, lhs.length(), rhs, rhs.size()); }