# Set variables set(VAR "hello cmake")

# Set variables set(VAR "hello cmake") # use variables message(${VAR})

# Set variables set(VAR "hello cmake") # use variables message(${VAR}) # Unload variables unset(VAR) message(${VAR}) # will report an error

set(VAR1 "hello") # 1. In the string, concatenate the value of the variable set(VAR2 "${VAR1} cmake") message(${VAR2}) # 2. In the string, the variables are output as they are, using escape characters message("\${VAR2}=${VAR2}")

set(VAR1 "hello") set(VAR2 "VAR1") # 1. Use the value of one variable as the name of another variable message(${${VAR2}})

#[[ 1. Grammar: \033[1,31,41m 1-Highlight 31-Foreground color red 40-Background color black \033[0m adopt the terminal default settings, that is, cancel the color settings 2. Display mode: 0 Terminal default settings 1 Highlight 2 3 4 Use underline 5 flashes 6 7 Highlight display 8 invisible 3. Color: foreground color background color color 30 40 black 31 41 red 32 42 green 33 43 yellow 34 44 blue 35 45 purple 36 46 cyan blue 37 47 white 38 48 39 49 ]] string(ASCII 27 Esc) set(B "${Esc}[") set(E "${Esc}[0m") set(Red "1;31m") set(Yellow "1;33;41m") message("${B}${Red}====This is a red word====${E}") message("${B}${Yellow}====This is a yellow word====${E}")

PROJECT_NAME

BUILD_SHARED_LIBS

MSVC

WIN32

ANDROID

UNIX

CMAKE_SYSTERM_NAME

message("MSVC=${MSVC}") message("WIN32=${WIN32}") message("UNIX=${UNIX}") message("ANDROID=${ANDROID}") message("CMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}") # window platform #MSVC=1 # WIN32=1 #CMAKE_SYSTEM_NAME=Windows # linux platform #UNIX=1 #CMAKE_SYSTEM_NAME=Linux

CMAKE_COLOR_MAKEFILE

# Pass macro variables to the c source file, equivalent to gcc -DSPD_LOG #Default value is: 1

# CMakeLists.txt file cmake_minimum_required(VERSION 3.20) project(demo02) add_definitions(-DSPD_LOG) add_executable(${PROJECT_NAME} main.cpp)

// main.cpp file #include <iostream> using namespace std; int main(int argc, char const *argv[]) { #ifdef SPD_LOG cout << "Log output function enabled...!" << endl; #else cout << "The log output function is not enabled...!" << endl; #endif return 0; }

cmake -S . -B build

cmake -S . -B build -G "NMake Makefiles"

cmake --build build --target help

cmake --build build --target all

cmake --build build --target xxx.i

cmake --build build --target xxx.s

cmake --build build --target xxx.o

cmake --build build

cmake --build build --target clean

set(<variable><value>...CHACHE <type><docstring>[FORCE])

variable variable name

value variable value

CHCHE sets a variable to a cache variable

type

docstring

FORCE

Ordinary variable scope, itself and submodules

CACHE variable scope is global

windows cmake-gui

linuxccmake

Use option to replace set

cmake_policy(SET CMP0126 OLD|NEW)

OLD deletes ordinary variables with the same name

NEW does not delete ordinary variables, but cache variables need to be accessed using $CACHE{var_name}

cmake -S . -B build -D CACHE_VAR1=bbbb

set_property(<GLOBAL | DIRECTORY [<dir>] | TARGET [<target1> ...] | SOURCE [<src1> ...] [DIRECTORY <dirs> ...] [TARGET_DIRECTORY <targets> ...] | INSTALL [<file1> ...] | TEST [<test1> ...] [DIRECTORY <dir>] | CACHE [<entry1> ...] > [APPEND] [APPEND_STRING] PROPERTY <name> [<value1> ...])

get_property(<variable> <GLOBAL | DIRECTORY [<dir>] | TARGET <target> | SOURCE <source> [DIRECTORY <dir> | TARGET_DIRECTORY <target>] | INSTALL <file> | TEST <test> [DIRECTORY <dir>] | CACHE <entry> | VARIABLE > PROPERTY <name> [SET | DEFINED | BRIEF_DOCS | FULL_DOCS])

define_property(<GLOBAL | DIRECTORY | TARGET | SOURCE | TEST | VARIABLE | CACHED_VARIABLE> PROPERTY <name> [INHERITED] [BRIEF_DOCS <brief-doc> [docs...]] [FULL_DOCS <full-doc> [docs...]] [INITIALIZE_FROM_VARIABLE <variable>])

global properties

directory properties

file properties

target attribute

# ============================================ # 1. Judgment constants # 1. Truth constant: # 1, ON, TRUE, YES, Y, non-zero value (including floating point numbers) # ============================================ if(1) message("1 is true") # true endif() if(ON) message("ON is true") # true endif() if(TRUE) message("TRUE is true") # true endif() if(Y) message("Y is true") # true endif() if(1.1) message("1.1 is true") # true endif() # ============================================ # 2. Judge as false # 0, OFF, FALSE, NO, N, IGNORE, NOTFOUND, empty string # , or the result of -NOTFOUND is false #ignore means ignoring # notfound means not found # ============================================ if(0) message("0 is true") else() message("0 is false") # false endif() if(IGNORE) message("IGNORE is true") else() message("IGNORE is false") # false endif() if(NOTFOUND) message("NOTFOUND is true") else() message("NOTFOUND is false") # false endif() if(xxx-NOTFOUND) message("xxx-NOTFOUND is true") else() message("xxx-NOTFOUND is false") # false endif()

# ============================================ # 2. Judgment variables # 1. A variable whose value is a true constant is true, and an undefined or other string is false. # 2. Environment variables are always false # 3. Macro parameters are not variables # ============================================ set(VER1 "1") if(${VER1}) # If the value is true, then it is true message("\"1\" is true") # true else() message("\"1\" is false") endif() set(VAR2 "0") if(${VER2}) # If the value is false, then it is false message("\"0\" is true") else() message("\"0\" is false") # false endif() if(${xxxx}) # The value of undefined variables is false message("xxxx undefined is true") else() message("xxxx undefined is false") # false endif() if(VAR0) #The undefined variable name is false message("VAR0 undefined is true") else() message("VAR0 undefined is false") # false endif() set(VAR3 "xxxx") if(VAR3) #The defined variable name is true message("\"xxxx\" is true") # true else() message("\"xxxx\" is false") endif() if(${PATH}) # All system environment variables are flase message("\"PATH\" is true") else() message("\"PATH\" is false") # false endif()

# ============================================ # 2. Determine the string # 1. If the constant is true, the string is true, and the other strings are false. # ============================================ if("aaa") # All system environment variables are flase message("\"PATH\" is true") else() message("\"PATH\" is false") # false endif() if("YES") message("\"YES\" is true") # true endif()

NOT

AND

OR

EXISTS determines whether it exists

COMMAND determines whether it is a command

DEFINED determines whether the variable has been defined

comparison operator

String judgment

version judgment

MATCHES

https://github.com/crow-misia/libwebrtc-bin

# define MD5_LONG unsigned int #define MD5_CBLOCK 64 # define MD5_LBLOCK (MD5_CBLOCK/4) #define MD5_DIGEST_LENGTH 16 //Hash value length typedef struct MD5state_st { MD5_LONG A, B, C, D; MD5_LONG Nl, Nh; MD5_LONG data[MD5_LBLOCK]; unsigned int num; } MD5_CTX; //md5 encryption structure //1.Initialization int MD5_Init(MD5_CTX* c); //Parameter Description: // - c parameter, initialize an MD5_CTX variable //2. Add data and perform md5 operation on the data int MD5_Update(MD5_CTX* c, const void* data, size_t len); //Parameter Description: // -c obtained by MD5_Init initialization // - data data for md5 operation // - length of len data string //3. Method 1 of calculating md5 hash value int MD5_Final(unsigned char* md, MD5_CTX* c); //Parameter Description: // - md outgoing parameters, hash value // -c obtained by MD5_Init initialization //instruction manual: // Data to be encrypted can be added multiple times, and large amounts of data can be processed // "hello world! Hello, world" // MD5_Update(c, "hello world!", strlen("hello world!")); // MD5_Update(c, "You,", strlen(" You,")); // MD5_Update(c, "World", strlen("World")); // unsigned char md[16] = { 0 }; // MD5_Final(md, c); //Added multiple times, only after adjusting the MD5_Final function are all encrypted // for (size_t i = 0; i < 16; i ) // { // sprintf(&outresult[i * 2], " x", md[i]); // } //4. Method 2 of calculating md5 hash value unsigned char* MD5(const unsigned char* d, size_t n, unsigned char* md); //Parameter Description: // - d data for md5f operation // - length of n d string // - md outgoing parameters, hash value //instruction manual: // The encrypted data must be added at once, and only a small amount of data can be processed //5. Internal calling function of MD5 void MD5_Transform(MD5_CTX* c, const unsigned char* b);

#include <string> #include <iostream> #include <openssl/md5.h> #include <openssl/sha.h> #pragma warning(disable:4996) using namespace std; void md5Test(const char* p) { //initialization MD5_CTX ctx; int ret = MD5_Init(&ctx); //adding data MD5_Update(&ctx, p, strlen(p)); //Calculation results unsigned char md[MD5_DIGEST_LENGTH] = { 0 }; MD5_Final(md, &ctx); cout << "MD5:" << md << endl; //Result: binary, output garbled code //Format hash value char res[MD5_DIGEST_LENGTH * 2 1] = { 0 }; for (size_t i = 0; i < MD5_DIGEST_LENGTH; i) { sprintf(&res[i*2], " x", md[i]); //&res[i*2] Address: 0 2 4 6 8 rule //"x" formats md[i] into a hexadecimal integer, // It occupies two digits, and if the conversion is less than two digits, fill it with 0 } cout << "Hexadecimal number of MD5:" << res << endl; } int main(int argc, char* argv[]) { const char* str = "hello world"; md5Test(str); system("pause"); return EXIT_SUCCESS; }

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <openssl/md5.h> #pragma warning(disable:4996) void getMD5(const char* str, char* outresult) { MD5_CTX ctx; //initialization MD5_Init(&ctx); //adding data MD5_Update(&ctx, str, strlen(str)); //Calculation results unsigned char md[16] = { 0 }; MD5_Final(md, &ctx); for (size_t i = 0; i < 16; i ) { sprintf(&outresult[i*2],"%02x", md[i]); } } int main(int argc, char* arrgv[]) { char result[33] = { 0 }; getMD5("hello, md5", result); printf("md5 value: %s ", result); system("pause"); return 0; }

// sudo apt install unicode // in unicode // Description of the problem of inconsistency between the local Chinese version and the website: // 1. Local Chinese, because the local encoding may occupy two characters // 2. The Chinese URL is converted according to utf8 encoding, which takes up three characters. // https://tool.oschina.net/encrypt?type=2 // 3. The solution: ensure that the local and website encodings are consistent, and then ensure that the md5 encrypted value with Chinese is the same. #include <string> #include <iostream> #include <openssl/md5.h> #include <openssl/sha.h> #include <codecvt> //Coding conversion header file #pragma warning(disable:4996) using namespace std; // Unicode character set conversion UTF8 std::string UnicodeToUTF8(const std::wstring& wstr) { std::string ret; try { std::wstring_convert< std::codecvt_utf8<wchar_t> > wcv; ret = wcv.to_bytes(wstr); } catch (const std::exception & e) { std::cerr << e.what() << std::endl; } return ret; } // UTF8 converts Unicode character set std::wstring UTF8ToUnicode(const std::string& str) { std::wstring ret; try { std::wstring_convert< std::codecvt_utf8<wchar_t> > wcv; ret = wcv.from_bytes(str); } catch (const std::exception & e) { std::cerr << e.what() << std::endl; } return ret; } void md5Test(const char* p) { //initialization MD5_CTX ctx; int ret = MD5_Init(&ctx); //adding data MD5_Update(&ctx, p, strlen(p)); //Calculation results unsigned char md[MD5_DIGEST_LENGTH] = { 0 }; MD5_Final(md, &ctx); cout << "MD5:" << md << endl; //Result: binary, output garbled code //Format hash value char res[MD5_DIGEST_LENGTH * 2 1] = { 0 }; for (size_t i = 0; i < MD5_DIGEST_LENGTH; i) { sprintf(&res[i*2], " x", md[i]); //&res[i*2] Address: 0 2 4 6 8 rule //"x" formats md[i] into a hexadecimal integer, // It occupies two digits, and if the conversion is less than two digits, fill it with 0 } cout << "Hexadecimal number of MD5:" << res << endl; } int main(int argc, char* argv[]) { std::wstring str = L"Hello world, hello world"; string aa = UnicodeToUTF8(str); md5Test(aa.c_str()); system("pause"); return EXIT_SUCCESS; }

//Step one: Generate RSA key pair: #include <openssl/rsa.h> //Apply for a piece of memory RSA* RSA_new(void); BIGNUM* BN_new(void); BIGNUM* e = BN_new(); //BIGNUM needs to be initialized, specify a relatively large integer, used as a random seed BN_set_bit(e, 1000000); //Generate a key pair and store the key in memory int RSA_generate_key_ex(RSA* rsa, int bits, BIGNUM* e, BN_GENCB* cb); //Parameter Description: // - rsa key structure, obtained through RSA_new(), the generated key pair will eventually be stored in this variable // - bits is the length of the key, the unit is bit, calculated in bytes bits/8=1Byte // - e BIGNUM structure variable, obtained through BN_new() // - cb callback function pointer, usually not used, just specify NULL //Extract the public key in the parameter rsa RSA* RSAPublicKey_dup(RSA* rsa); //Extract the private key in the parameter rsa RSA* RSAPrivateKey_dup(RSA* rsa);

pem format writing

bio format writing

//Step 3: Encrypt data // 1. Encrypted in blocks, the length of the encrypted data cannot be greater than the length of the secret key // Assumption: Secret key length: 1024bit/8 = 128Byte //【Master】Usually this is used for data transmission //Public key encryption int RSA_public_encrypt(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding); //Private key decryption int RSA_private_decrypt(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding); //[Understand] Usually this is not used for data transmission //Private key encryption int RSA_private_encrypt(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding); //Public key decryption int RSA_public_decrypt(int flen, const unsigned char* from, unsigned char* to, RSA* rsa, int padding); //Parameter Description: // -flen The length of the data to be added/decrypted -- cannot be greater than the length of the secret key //The maximum length of data that can be encrypted is: the length of the secret key minus 11; // -from the data to be encrypted/decrypted -- passing in parameters // -to store the encrypted or decrypted data -- outgoing transfer number // -rsa public key/private key // -padding fills the end mark, used when reading to indicate that the end of the key has been read. //General use: RSA_PKCS1_PADDING occupies 11 bytes //return value: // Failure: return -1 // Success: Return >0, the length of the binary data after encryption //Use public key encryption string encryptPublicKey() { //1. Get the public key - read the public key from the file FILE* fp = fopen("publicKey.pem", "r"); RSA* pubKey = RSA_new(); PEM_read_RSAPublicKey(fp, &pubKey, NULL, NULL); //2. Prepare encrypted data int keylen = RSA_size(pubKey); // Calculate the maximum length of encryptable data const char* str = "Nima let programming change the world - good good study, day day up!!!"; //3. Use public key encryption char *buf = new char[1024]; memset(buf, 0, sizeof(buf)); int len ​​= RSA_public_encrypt(strlen(str), (const unsigned char*)str, (unsigned char*)buf, pubKey, RSA_PKCS1_PADDING); //4. Return the encrypted data string val = string(buf, len); delete[] buf; RSA_free(pubKey); return val; } //Decrypt using private key string decryptPrivateKey(string encstr) { //1. Get the private key - read the private key from the file FILE* fp = fopen("privateKey.pem", "r"); RSA* priKey = RSA_new(); PEM_read_RSAPrivateKey(fp, &priKey, NULL, NULL); //2. The data to be decrypted is the encstr passed in. int keylen = RSA_size(priKey); // Calculate the maximum length of encryptable data //3. Decrypt using private key char* buf = new char[1024]; memset(buf, 0, sizeof(buf)); int len ​​= RSA_private_decrypt(encstr.size(), (const unsigned char*)encstr.c_str(), (unsigned char*)buf, priKey, RSA_PKCS1_PADDING); //4. Return the encrypted data string val = string(buf, len); delete[] buf; RSA_free(priKey); return val; } int main(int argc, char* arrgv[]) { string str = encryptPublicKey(); cout << "Encrypted data:" << str << endl; string str2 = decryptPrivateKey(str); cout << "Decrypted data:" << str2 << endl; system("pause"); return 0; }

//data signature int RSA_sign(int type, const unsigned char* m, unsigned int m_length, unsigned char* sigret, unsigned int* siglen, RSA * rsa); //Parameter Description: // -type macro, specifies the hash algorithm used, NID_MD5/NID_SHA1/NID_SH224 // -m The data to be signed, // -m_length Signature data length, parameter 2 length strlen(m) // -sigret outgoing parameters, data after signature // -siglen gets the data length after signature // -rsa private key //return value: // Failure: return -1 // Success: Return >0, the length of the signed data //Verify signature int RSA_verify(int type, const unsigned char* m, unsigned int m_length, const unsigned char* sigbuf, unsigned int siglen, RSA * rsa); //Parameter Description: // -type macro, specifies the hash algorithm used, NID_MD5/NID_SHA1/NID_SH224 // -m The data to be signed, // -m_length signature data length // -sigret passed in parameter, signed data sigret, signature to be verified // -siglen To verify the data length of the signature // -rsa public key //return value: // Failure: return -1 // Success: return=1, verification successful //data signature string data_RSASign(string str) { char buf[1024] = { 0 }; unsigned int buflen = 0; RSA* priKey = RSA_new(); BIO* priio = BIO_new_file("privateKey.pem", "r"); PEM_read_bio_RSAPrivateKey(priio, &priKey, NULL, NULL); int ret = RSA_sign(NID_sha1, (const unsigned char*)str.data(), str.length(), (unsigned char*)buf, &buflen, priKey); RSA_free(priKey); BIO_free(priio); return string(buf, buflen); } //verify the data int data_RSAVerify(string str, string sign) { RSA* pubKey = RSA_new(); BIO* pubio = BIO_new_file("publicKey.pem", "r"); PEM_read_bio_RSAPublicKey(pubio, &pubKey, NULL, NULL); int ret = RSA_verify(NID_sha1, (const unsigned char*)str.data(), str.length(), (const unsigned char*)sign.data(), sign.length(), pubKey); RSA_free(pubKey); BIO_free(pubio); return ret; } int main(int argc, char* argv[]) { const char* msg1 = "Hello, world! hello world!"; const char* msg2 = "Hello, world! hello world!"; string str = data_RSASign(msg1); int ret = data_RSAVerify(msg2, str); if (ret == 1)cout << "Verification successful" << endl; else cout << "Verification failed" << endl; system("pause"); return EXIT_SUCCESS; }

Install miniconda

Install pytorch

Install yolov5

Install miniconda

Install pytorch

Install yolov5

Step 1: In the yolov5 environment of conda, install jupyterlab pip install jupyterlab Step 2: Create files 1. Open the yolov5 source code root directory with vscode 2. In the root directory, create the file hub_detect.ipynb 3. In vscode, Double-click hub_detect.ipynb to open the third step: enter the following content: import torch # model # Parameter one: the path to the directory where the model is located # Parameter two: the name of the model file, the .pt suffix cannot be added # Parameter three: Represents the local yolov5 environment model = torch.hub.load("./", "yolov5s", source="local") # images # The content to be detected, img = "./data/images/zidane.jpg" # infererce # Call the model and perform detection results = model(img) # results # Display the detection results results.show() Step 4: Click to run