[Bf-blender-cvs] [8dec6452f22] master: Cryptomatte: Session from Existing Render Result.
Jeroen Bakker
noreply at git.blender.org
Tue Mar 2 10:17:35 CET 2021
Commit: 8dec6452f22013ee98246ea6d7631c2201a6de3a
Author: Jeroen Bakker
Date: Tue Mar 2 10:14:10 2021 +0100
Branches: master
https://developer.blender.org/rB8dec6452f22013ee98246ea6d7631c2201a6de3a
Cryptomatte: Session from Existing Render Result.
Utility to construct a cryptomatte session from a render result or
openexr file. This will allow D3959 to be more aware of the context
it is working on and would also support external render engines in
the cryptomatte color picker.
===================================================================
M source/blender/blenkernel/BKE_cryptomatte.h
M source/blender/blenkernel/BKE_cryptomatte.hh
M source/blender/blenkernel/intern/cryptomatte.cc
M source/blender/blenkernel/intern/cryptomatte_test.cc
===================================================================
diff --git a/source/blender/blenkernel/BKE_cryptomatte.h b/source/blender/blenkernel/BKE_cryptomatte.h
index 8428b5287c1..96e853e7ff8 100644
--- a/source/blender/blenkernel/BKE_cryptomatte.h
+++ b/source/blender/blenkernel/BKE_cryptomatte.h
@@ -38,6 +38,8 @@ struct Object;
struct RenderResult;
struct CryptomatteSession *BKE_cryptomatte_init(void);
+struct CryptomatteSession *BKE_cryptomatte_init_from_render_result(
+ const struct RenderResult *render_result);
void BKE_cryptomatte_free(struct CryptomatteSession *session);
void BKE_cryptomatte_add_layer(struct CryptomatteSession *session, const char *layer_name);
diff --git a/source/blender/blenkernel/BKE_cryptomatte.hh b/source/blender/blenkernel/BKE_cryptomatte.hh
index 16f4da18e1e..f10b4c1f7c4 100644
--- a/source/blender/blenkernel/BKE_cryptomatte.hh
+++ b/source/blender/blenkernel/BKE_cryptomatte.hh
@@ -86,4 +86,21 @@ struct CryptomatteLayer {
std::optional<std::string> operator[](float encoded_hash) const;
};
+struct CryptomatteStampDataCallbackData {
+ struct CryptomatteSession *session;
+ blender::Map<std::string, std::string> hash_to_layer_name;
+
+ /**
+ * Extract the hash from a stamp data key.
+ *
+ * Cryptomatte keys are formatted as "cryptomatte/{layer_hash}/{attribute}".
+ */
+ static blender::StringRef extract_layer_hash(blender::StringRefNull key);
+
+ /* C type callback function (StampCallback). */
+ static void extract_layer_names(void *_data, const char *propname, char *propvalue, int len);
+ /* C type callback function (StampCallback). */
+ static void extract_layer_manifest(void *_data, const char *propname, char *propvalue, int len);
+};
+
} // namespace blender::bke::cryptomatte
diff --git a/source/blender/blenkernel/intern/cryptomatte.cc b/source/blender/blenkernel/intern/cryptomatte.cc
index 3ecbbe56a22..a20c53ed270 100644
--- a/source/blender/blenkernel/intern/cryptomatte.cc
+++ b/source/blender/blenkernel/intern/cryptomatte.cc
@@ -37,6 +37,8 @@
#include "BLI_listbase.h"
#include "BLI_string.h"
+#include "RE_pipeline.h"
+
#include "MEM_guardedalloc.h"
#include <cctype>
@@ -51,6 +53,7 @@ struct CryptomatteSession {
CryptomatteSession();
CryptomatteSession(const Main *bmain);
+ CryptomatteSession(StampData *metadata);
blender::bke::cryptomatte::CryptomatteLayer &add_layer(std::string layer_name);
std::optional<std::string> operator[](float encoded_hash) const;
@@ -80,6 +83,22 @@ CryptomatteSession::CryptomatteSession(const Main *bmain)
}
}
+CryptomatteSession::CryptomatteSession(StampData *stamp_data)
+{
+ blender::bke::cryptomatte::CryptomatteStampDataCallbackData callback_data;
+ callback_data.session = this;
+ BKE_stamp_info_callback(
+ &callback_data,
+ stamp_data,
+ blender::bke::cryptomatte::CryptomatteStampDataCallbackData::extract_layer_names,
+ false);
+ BKE_stamp_info_callback(
+ &callback_data,
+ stamp_data,
+ blender::bke::cryptomatte::CryptomatteStampDataCallbackData::extract_layer_manifest,
+ false);
+}
+
blender::bke::cryptomatte::CryptomatteLayer &CryptomatteSession::add_layer(std::string layer_name)
{
return layers.lookup_or_add_default(layer_name);
@@ -102,6 +121,13 @@ CryptomatteSession *BKE_cryptomatte_init(void)
return session;
}
+struct CryptomatteSession *BKE_cryptomatte_init_from_render_result(
+ const struct RenderResult *render_result)
+{
+ CryptomatteSession *session = new CryptomatteSession(render_result->stamp_data);
+ return session;
+}
+
void BKE_cryptomatte_add_layer(struct CryptomatteSession *session, const char *layer_name)
{
session->add_layer(layer_name);
@@ -502,4 +528,65 @@ std::string CryptomatteLayer::manifest() const
return blender::bke::cryptomatte::manifest::to_manifest(this);
}
+blender::StringRef CryptomatteStampDataCallbackData::extract_layer_hash(blender::StringRefNull key)
+{
+ BLI_assert(key.startswith("cryptomatte/"));
+
+ size_t start_index = key.find_first_of('/');
+ size_t end_index = key.find_last_of('/');
+ if (start_index == blender::StringRef::not_found) {
+ return "";
+ }
+ if (end_index == blender::StringRef::not_found) {
+ return "";
+ }
+ if (end_index <= start_index) {
+ return "";
+ }
+ return key.substr(start_index + 1, end_index - start_index - 1);
+}
+
+void CryptomatteStampDataCallbackData::extract_layer_names(void *_data,
+ const char *propname,
+ char *propvalue,
+ int UNUSED(len))
+{
+ CryptomatteStampDataCallbackData *data = static_cast<CryptomatteStampDataCallbackData *>(_data);
+
+ blender::StringRefNull key(propname);
+ if (!key.startswith("cryptomatte/")) {
+ return;
+ }
+ if (!key.endswith("/name")) {
+ return;
+ }
+ blender::StringRef layer_hash = extract_layer_hash(key);
+ data->hash_to_layer_name.add(layer_hash, propvalue);
+}
+
+/* C type callback function (StampCallback). */
+void CryptomatteStampDataCallbackData::extract_layer_manifest(void *_data,
+ const char *propname,
+ char *propvalue,
+ int UNUSED(len))
+{
+ CryptomatteStampDataCallbackData *data = static_cast<CryptomatteStampDataCallbackData *>(_data);
+
+ blender::StringRefNull key(propname);
+ if (!key.startswith("cryptomatte/")) {
+ return;
+ }
+ if (!key.endswith("/manifest")) {
+ return;
+ }
+ blender::StringRef layer_hash = extract_layer_hash(key);
+ if (!data->hash_to_layer_name.contains(layer_hash)) {
+ return;
+ }
+
+ blender::StringRef layer_name = data->hash_to_layer_name.lookup(layer_hash);
+ blender::bke::cryptomatte::CryptomatteLayer &layer = data->session->add_layer(layer_name);
+ blender::bke::cryptomatte::manifest::from_manifest(layer, propvalue);
+}
+
} // namespace blender::bke::cryptomatte
diff --git a/source/blender/blenkernel/intern/cryptomatte_test.cc b/source/blender/blenkernel/intern/cryptomatte_test.cc
index 4a25f5f7d87..d9be252d654 100644
--- a/source/blender/blenkernel/intern/cryptomatte_test.cc
+++ b/source/blender/blenkernel/intern/cryptomatte_test.cc
@@ -17,7 +17,13 @@
*/
#include "testing/testing.h"
+#include "BKE_cryptomatte.h"
#include "BKE_cryptomatte.hh"
+#include "BKE_image.h"
+
+#include "RE_pipeline.h"
+
+#include "MEM_guardedalloc.h"
namespace blender::bke::cryptomatte::tests {
@@ -41,7 +47,7 @@ TEST(cryptomatte, extract_layer_name)
ASSERT_EQ("", BKE_cryptomatte_extract_layer_name(""));
}
-TEST(cryptomatte, cryptomatte_layer)
+TEST(cryptomatte, layer)
{
blender::bke::cryptomatte::CryptomatteLayer layer;
ASSERT_EQ("{}", layer.manifest());
@@ -53,7 +59,7 @@ TEST(cryptomatte, cryptomatte_layer)
ASSERT_EQ("{\"Object\":\"0000007b\",\"Object2\":\"0758946e\"}", layer.manifest());
}
-TEST(cryptomatte, cryptomatte_layer_quoted)
+TEST(cryptomatte, layer_quoted)
{
blender::bke::cryptomatte::CryptomatteLayer layer;
layer.add_hash("\"Object\"", 123);
@@ -66,7 +72,7 @@ static void test_cryptomatte_manifest(std::string expected, std::string manifest
blender::bke::cryptomatte::CryptomatteLayer::read_from_manifest(manifest)->manifest());
}
-TEST(cryptomatte, cryptomatte_layer_from_manifest)
+TEST(cryptomatte, layer_from_manifest)
{
test_cryptomatte_manifest("{}", "{}");
test_cryptomatte_manifest("{\"Object\":\"12345678\"}", "{\"Object\": \"12345678\"}");
@@ -82,4 +88,92 @@ TEST(cryptomatte, cryptomatte_layer_from_manifest)
"{\"Object\\\"01\\\"\":\"12345678\",\"Object\":\"12345678\", \"Object2\":\"87654321\"}");
}
+TEST(cryptomatte, extract_layer_hash_from_metadata_key)
+{
+ EXPECT_EQ("eb4c67b",
+ blender::bke::cryptomatte::CryptomatteStampDataCallbackData::extract_layer_hash(
+ "cryptomatte/eb4c67b/conversion"));
+ EXPECT_EQ("qwerty",
+ blender::bke::cryptomatte::CryptomatteStampDataCallbackData::extract_layer_hash(
+ "cryptomatte/qwerty/name"));
+ /* Check if undefined behaviors are handled. */
+ EXPECT_EQ("",
+ blender::bke::cryptomatte::CryptomatteStampDataCallbackData::extract_layer_hash(
+ "cryptomatte/name"));
+ EXPECT_EQ("",
+ blender::bke::cryptomatte::CryptomatteStampDataCallbackData::extract_layer_hash(
+ "cryptomatte/"));
+}
+
+static void validate_cryptomatte_session_from_stamp_data(void *UNUSED(data),
+ const char *propname,
+ char *propvalue,
+ int UNUSED(len))
+{
+ blender::StringRefNull prop_name(propname);
+ if (!prop_name.startswith("cryptomatte/")) {
+ return;
+ }
+
+ if (prop_name == "cryptomatte/87f095e/name") {
+ EXPECT_STREQ("viewlayername.layer1", propvalue);
+ }
+ else if (prop_name == "cryptomatte/87f095e/hash") {
+ EXPECT_STREQ("MurmurHash3_32", propvalue);
+ }
+ else if (prop_name == "cryptomatte/87f095e/conversion") {
+ EXPECT_STREQ("uint32_to_float32", propvalue);
+ }
+ else if (prop_name == "cryptomatte/87f095e/manifest") {
+ EXPECT_STREQ("{\"Object\":\"12345678\"}", propvalue);
+ }
+
+ else if (prop_name == "cryptomatte/c42daa7/name") {
+ EXPECT_STREQ("viewlayername.layer2", propvalue);
+ }
+ else if (prop_name == "cryptomatte/c42daa7/hash") {
+ EXPECT_STREQ("MurmurHash3_32", propvalue);
+ }
+ else if (prop_name == "cryptomatte/c42daa7/conversion") {
+ EXPECT_STREQ("uint32_to_float32", propvalue);
+ }
+ else if (prop_name == "cryptomatte/c42daa7/manifest") {
+ EXPECT_STREQ("{\"Object2\":\"87654321\"}", propvalue);
+ }
+
+ else {
+ EXPECT_EQ("Unhandled", std::string(propname) + ": " + propvalue);
+ }
+}
+
+TEST(cryptomatte, session_from_stamp_data)
+{
+ /* Create CryptomatteSession from stamp data. */
+ RenderResult *render_result = static_cast<RenderResult *>(
+ MEM_callocN(sizeof(RenderResult), __func__));
+ BKE_render_result_stamp_data(render
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list