Inlägg

Så du menar att "Windows.h" är så bakåtkompatibel som det kan bli?

Bloodshed Dev var liksom #1 IDE innan Microsoft släppte sin Visual Studio gratis. Idag så används knappt Bloodshed Dev, mest bara av gurus inom C och C++ som hör till den gamla goda tiden.

Men jag behöver lite hjälp med information.
Hur kan jag hitta API:er för att skanna filer i en mapp i Win95? På microsofts sida så finns det för WinXP och uppåt. Men inte Win2000 och nedåt.

Undra om jag kan kompilera C kod på min Win11 maskin till Win95?

Har en Windows 95 maskin med 2 GB hårddisk. Det är en Compaq Armada 4150T med docka. Allt fungerar på den...utom diskettstationen. Diskettstationen har ett gummiband som är sönder som jag måste byta ut då allt bara snurrar där inne.

Hur som helst så vill jag kompilera C-kod på denna maskin. Bara för kul liksom!
Har ni några förslag till väga?

Bloodshed Dev C++ 4.01 verkar passa Windows 95. Min C-kod är för ANSI C. Största problemet är att få alla mina .c och .h filer att fungera med Bloodshet Dev C++ 4.0.1.

En nackdel är att viss del av C koden så skannar jag filer i mappar. Då använder jag Windows egna API:er som har minimumkrav minst för Windows XP, typ strukturen WIN32_FIND_DATA.

Egentligen så ska jag bara köra en .exe fil på Windows 95 datorn. Så jag behöver inte koda riktigt. Bara kompilera koden.

Så om jag anropar flera funktioner med olika argument så kommer den anropa en helt funktion med alla argument?

Dvs, allt på en gång.

En liten svår fråga. Men vi säger att jag har en kod som kopierar samma array 100 gånger, än fast det behövs bara en gång. Om jag sätter en optimeringsflagga, kommer då koden ta bort all onödiga iterationer eller kodrader då?

Vi kan ta detta exempel. Här är två kodsnuttar. Dom gör exakt samma sak. Skillnaden är att en är mer optimerad. Dock så visar Godbolt att angleanalysis2 genererar mindre assemblerkod än angleanalysis1.

Jag vet att man ska prioritera att skriva läsbar kod, istället för superavancerad som är optimerad. Man ska alltså låta kompilator sköta denna del. Men ibland så kan det vara bra att optimera för hand också igenom att minska på antalet iterationer.

Men vad kommer gå snabbast här enligt er?

void angleanalysis1(const float X[], const size_t row, const size_t column) {
	/* Constants and variables */
	const size_t column_bytes = column * sizeof(float);
	const size_t row_minus_1 = row - 1;

	/* Create two vectors */
	float* vector_A = (float*)malloc(column_bytes);
	float* vector_B = (float*)malloc(column_bytes);

	/* Find the angles between vectors from each cluster point */
	size_t i, j, k;
	for (i = 0; i < row; i++) {
		/* Select the "centroid" */
		float* centroid = &X[i * column];

		/* Select vector A */
		if (i < row_minus_1) {
			memcpy(vector_A, &X[(i+1) * column], column_bytes);

			/* Center the vector */
			for (k = 0; k < column; k++) {
				vector_A[k] -= centroid[k];
			}
		}

		/* Iterate the rest of the points */
		for (j = 0; j < row; j++) {
			if (i != j) {
				/* Select vector B */
				memcpy(vector_B, &X[j * column], column_bytes);

				/* Center the vector */
				for (k = 0; k < column; k++) {
					vector_B[k] -= centroid[k];
				}

				/* Compute the angle between vector A and vector B */
				float angle = anglevector(vector_A, vector_B, column);

			}
		}
	}
}

void angleanalysis2(const float X[], const size_t row, const size_t column) {
	/* Constants and variables */
	const size_t column_bytes = column * sizeof(float);
	size_t i, j, k;

	/* Create two vectors */
	float* vector_A = (float*)malloc(column_bytes);
	float* vector_B = (float*)malloc(column_bytes);

	/* Find the angles between vectors from each cluster point */
	for (i = 0; i < row; i++) {
		/* Select the "centroid" */
		float* centroid = &X[i * column];

		/* Iterate the rest of the points */
		for (j = 0; j < row; j++) {
			if (i != j) {
				/* Select vector A and vector B */
				memcpy(vector_A, &X[i * column], column_bytes);
				memcpy(vector_B, &X[j * column], column_bytes);

				/* Center the vectors */
				for (k = 0; k < column; k++) {
					vector_B[k] -= centroid[k];
					vector_A[k] -= centroid[k];
				}

				/* Compute the angle between vector A and vector B */
				float angle = anglevector(vector_A, vector_B, column);

			}
		}
	}
}

Du verkar vara väldigt insatt i just datorseende.
Jag har funderat på en sak.

Mitt mål är att kunna känna igen objekt från bilder. Så det är därför jag håller på dra linjer hit och dit.
Men.......det finns något som heter FAST - Feature Accelerated Segmented Test. Det är alltså en hörn-detektionslagoritm....typ.
I praktiken så kommer den ge hörn...plus mycket mer annat också. Typ så här.

https://i.ibb.co/9nBsHZn/Sk-rmbild-2023-11-15-195844.png

Så det finns alltså "hörn" lite överallt i denna bild. Fast det är bara FAST som upptäcker dessa "hörn". Så algoritmen kallas för feature detection. På Svenska heter det intressepunkter, vilket är koordinater.

Min idé med dessa intressepunkter är att man drar linjer mellan varje punkt som befinner sig den maximala L2-norm (Pythagoras sats om det är 2D) avstånd.

https://i.ibb.co/zbygjXn/Sk-rmbild-2023-11-15-195844.png

Så tänkt att vi utför detta:

1. Vi tar en bild

2. Använder FAST för att hitta intressepunkterna

3. Drar linje mellan alla punkter. Linjerna ska gå mellan längsta avståndet

Så om vi mäter varje vinkel mellan varje linje, så kan vi få typ ett histogram. Detta histogrammet kan vi klassificera via Support Vector Machine (SVM).

Men då är frågan:
Kommer detta att fungera?
Jag menar, om man börjar med att ta den mest avlägsna punkt från origo (0,0) så kommer man hamna ungefär på samma avstånd om FAST algoritmen körs i realtid + brus från en kamera. Sedan från den valda punkten, till en annan avlägsen punkt.

Då kan man hitta vinklarna mellan varje linje. Dessa vinklar är robust mot rotationer. Så oavsett hur kameran vrids så är vinklarna det samma.

Tänk att göra ett histogram av detta: Hur många vinklar fick vi som var mellan 20 till 25 grader? Hur många vinklar fick vid som var mellan 26 till 31 grader?

Histogram är ju nyckeln till att klassificera data.

Här hittar du FAST i C-kod:
https://github.com/edrosten/fast-C-src

Här är Matlab-versionen:
https://www.edwardrosten.com/work/fast.html

Jag förstår ditt tankesätt. Du vill alltså kolla om en korsning innehåller t.ex. vit 8x8 matris i sitt medelvärde.

Detta blir väldigt svårt att verifiera dock. Någon som vet hur OpenCV gör?

Om ni övriga undrar vad målet ska vara, så ska jag kunna detektera speciella egenskaper i bilder. Att rita ut boxar är en egenskap dock.

Orsaken varför jag skriver eget har med att OpenCV passar inte små inbyggda system. Jag extraherar vikter från t.ex. modeller som passar på inbyggda system. Detta är något helt nytt, och det kommer bli vanligare inom 5 år.

Så utgången från Sobel filtret kan jag ha som lagermask, ja. Så jag följer bara en y = k*x + m linje och kollar om koordinaten (x, y) befinner sig på vit färg (pixelvärde 255)?

Antag att vi har denna bild

https://i.stack.imgur.com/Aa8Qj.png

Den vänstra bilden är skapat med Hough Transform för att hitta linjer i en bild.
Den högra bilden är skapat med Sobel operator, för att hitta konturer i bilder.

För att skapa en linje för en box så måste man först använda Sobel, och sedan använda Hough Transform.
När jag utför Hough Transform för den högra bilden så ser det ut så här.

https://i.ibb.co/KL7DJ9T/Sk-rmbild-2023-11-12-105138.png

Min Hough Transform algoritm har jag skrivit själv, och den är något bättre än OpenCV's algoritm då min hough transoform skapar inte dubbletter av linjer.

Varje linje är alltså en matematisk definition på räta linjens ekvation - Räta linjens ekvation (Matematik årkurs 9).

Y = K*x + M

Där K är lutningen på linjen och M är skärningspunkten i Y-axlen där x = 0.

Fråga:
Om du vet alla ekvationer för varje linje

for i = 1:N
   Y(i) = K(i)*x + M(i)
end

Du jämför en linje mot en annan vinkelrät linje, och märker att dom har en vinkel som är mellan 80 till 100 grader, alltså en kant. Hur kan du vara säker på att det är en låda?

För man kan lika gärna få en bild som visar detta.

https://i.ibb.co/M5fQPvd/Sk-rmbild-2023-11-12-105845.png

Hur många boxar ser ni om ni skulle få denna bild?

https://i.ibb.co/cDjbHq8/Sk-rmbild-2023-11-12-110133.png

Vad tror ni?

Kan säga att skriver man något i en gammal tråd på detta forum, så svarar ingen. Det är bara i nya trådar som folk svarar. Därför skapar jag ny tråd.

När jag läser teorin om att utföra Sobel så är det ganska mycket. Det är egentligen inte bara ta differensen mellan två olika pixlar. Det är lite mera matematik.

Jag vet dock inte om det att jämföra två pixlar i taget, eller om man måste summera pixlarna.

Ja, det finns mycket kunnigt folk här, i alla fall på programmeringssidan typ web. Men när det kommer till optimering, algoritmer och matematik så är det dock en bristvara.

Ja, i detta fall använder jag FFT2D för att göra konventionell matrixmultiplikation.
Med lite enkel MATLAB-kod så kan man beskriva detta som

% Create kernel
[m, n] = size(X);
kernel = zeros(m, n);
[m, n] = size(K);

% Compute the sizes
m_middle = ceil(m/2);
n_middle = ceil(n/2);

% Insert kernel
kernel(1:m_middle, 1:n_middle) = K(m_middle:end, n_middle:end);
kernel(end, 1:n_middle) = K(1, n_middle:end);
kernel(1:m_middle, end) = K(m_middle:end, 1);
kernel(end, end) = K(1,1);

% Do FFT2 on X and kernel
A = fft2(X);
B = fft2(kernel);

% Compute the convolutional matrix - real to remove zero imaginary numbers
C = real(ifft2(A.*B));

Där C matrisen är själva utgången som man önskar.

Jag försöker optimera lite.

Antag att vi ska göra om denna bild

https://upload.wikimedia.org/wikipedia/commons/f/f0/Valve_origin...

Till denna bild. Det bilden visar är gradienterna mellan olika pixlar. Det kan vara t.ex att om pixel 1 har värdet 0 (svart) och pixel 2 har värdet 255 (vit). Skillnaden mellan pixel 1 och pixel 2 är 255.

https://upload.wikimedia.org/wikipedia/commons/thumb/d/d4/Valve_...

För att hitta gradienterna (skillnaden mellan pixlarna) så finns det Sobel, Canny, Prewitt, LoG, Roberts osv. Alla dessa ger olika egenskaper i bilden. Sobel ger egenskapen att man får en kontur runt om ett objekt, vilket jag vill ha.

För att hitta Sobel-gradienter från en bild så kan man antingen använda två stycken for-satser som itererar över varje pixel i varje bild. Eller så kan man använda FFT2D för att utföra konventionell matrismultiplikation. För konventionell matrismultiplikation så behövs en kärna K som är en matris som man "drar" över hela bilden. Kärnan är antingen en 3x3 eller 5x5.

https://miro.medium.com/v2/resize:fit:1052/1*ZCjPUFrB6eHPRi4eyP6...

Fråga:
Vem är snabbast för en bild som har M rader och N kolumner.

• Konventionell matrismultiplikation med FFT2D som är hårdvaruoptimerad

• Två for-satser för att iterera

I detta fall så handlar språket om C och mjukvaran Math Kernel Library eller CMSIS

Ja, den frigör minnet under programmets körning. Den allokerar inte mer minne än vid behov.

Det är AI som jag håller på med...i rent C

Det är tydligen en statisk array som jag ej frigör minnet på vid avslut av program.

Det är en statisk array som kan hålla i 16 strukturer. Dessa strukturer måste allokeras. Strukturerna innehåller data av olika längd. Tanken är att dom ska fungera som en behållare som roterar sin indexposition. Dvs index 0 får ny allokering, sedan får index 1 ny allokering osv. När man kommer till index 16 så börjar den om på index 0 igen, fast nu frigör den minnet.

Eller hur gör man här? Bör man ens göra något åt detta?

Jag hade definierat _CRTDBG_MAP_ALLOC, men skrivit _CRTDGB_MAP_ALLOC istället.

Nu fungerar det.

C:\Users\dmn\GitHub\Main\src\CControl\Sources\MachineLearning\fasto.c(18302) : {1189} normal block at 0x000002A1EABCD9B0, 4864 bytes long.
 Data: <%       '       > 25 00 00 00 08 00 00 00 27 00 00 00 09 00 00 00

Då ser jag att det är något som ej frigörs.

Svårt med att hålla koll på minnet i C. Utmanande.

Jag förväntar mig vart minnesläckan finns i koden.
Precis som på filmen.

Jag har testat med att detektera minnesläckage.
Jag såg på denna film:
https://www.youtube.com/watch?v=t1wqj6J6Vhs&ab_channel=CodeVa...

Jag har inkluderat den där define

#define _CRTDGB_MAP_ALLOC				/* Memory leackage library for Visual Studio */

och

#ifdef _MSC_VER
#include <crtdbg.h>
#endif /* !_MSC_VER */

Samt denna kod-rad på slutet av min main.c fil

_CrtDumpMemoryLeaks();

Men jag får bara:

'Main.exe' (Win32): Loaded 'C:\Users\dmn\GitHub\Main\x64\Debug\Main.exe'. Symbols loaded.
'Main.exe' (Win32): Loaded 'C:\Windows\System32\ntdll.dll'. 
'Main.exe' (Win32): Loaded 'C:\Windows\System32\kernel32.dll'. 
'Main.exe' (Win32): Loaded 'C:\Windows\System32\KernelBase.dll'. 
'Main.exe' (Win32): Loaded 'C:\Program Files (x86)\Intel\oneAPI\mkl\2023.2.0\redist\intel64\mkl_sequential.2.dll'. Module was built without symbols.
'Main.exe' (Win32): Loaded 'C:\Windows\System32\vcruntime140d.dll'. 
'Main.exe' (Win32): Loaded 'C:\Windows\System32\ucrtbased.dll'. 
The thread 0x3bcc has exited with code 0 (0x0).
'Main.exe' (Win32): Loaded 'C:\Program Files (x86)\Intel\oneAPI\mkl\2023.2.0\redist\intel64\mkl_core.2.dll'. Module was built without symbols.
'Main.exe' (Win32): Loaded 'C:\Program Files (x86)\Intel\oneAPI\mkl\2023.2.0\redist\intel64\mkl_avx512.2.dll'. Module was built without symbols.
'Main.exe' (Win32): Loaded 'C:\Program Files (x86)\Intel\oneAPI\mkl\2023.2.0\redist\intel64\mkl_vml_avx512.2.dll'. Module was built without symbols.
'Main.exe' (Win32): Loaded 'C:\Program Files (x86)\Intel\oneAPI\mkl\2023.2.0\redist\intel64\libimalloc.dll'. Module was built without symbols.
'Main.exe' (Win32): Unloaded 'C:\Program Files (x86)\Intel\oneAPI\mkl\2023.2.0\redist\intel64\libimalloc.dll'
'Main.exe' (Win32): Loaded 'C:\Program Files (x86)\Intel\oneAPI\mkl\2023.2.0\redist\intel64\libimalloc.dll'. Module was built without symbols.
'Main.exe' (Win32): Unloaded 'C:\Program Files (x86)\Intel\oneAPI\mkl\2023.2.0\redist\intel64\libimalloc.dll'
Detected memory leaks!
Dumping objects ->
{1189} normal block at 0x00000155357ED9B0, 4864 bytes long.
 Data: <%       '       > 25 00 00 00 08 00 00 00 27 00 00 00 09 00 00 00 
Object dump complete.
'Main.exe' (Win32): Loaded 'C:\Windows\System32\kernel.appcore.dll'. 
'Main.exe' (Win32): Loaded 'C:\Windows\System32\msvcrt.dll'. 
The thread 0x59c8 has exited with code 0 (0x0).
The thread 0x37c4 has exited with code 0 (0x0).
The program '[17220] Main.exe' has exited with code 0 (0x0).

Varför blir det så här?
Har jag missat något?

Jag har kört både QT och WinForms osv. Visst, dom fungerar....men dom är riktigt tråkiga, samt när projektet börjar bli stort, så är det mycket kod...och en sak till....allt är en klass.

Har @jaqob testat ImGui?

Ska detta vara ett problem att ett företag måste betala en licens?
Jag menar, man får ju mycket tillbaka om man använder ett verktyg som underlättar.

Tänk om alla hade använt CMake...vad dyr utvecklingstiden skulle vara då.

Tanken är att Visual Studio ska vara enkelt att skapa en applikation med, oavsett språk. Men det kommer självklart till ett pris.