WebSVN – filter_foundry – Diff – /trunk/funcs.c



extern value_type cell[], var[];
extern unsigned char* image_ptr;
 
// -------------------------------------------------------------------------------------------
 
void init_trigtab(void) {
#ifdef PARSERTEST
        return;
#else
        int i;
 

#endif
}
 
// -------------------------------------------------------------------------------------------
 
void factory_initialize_rnd_variables(void) {
#ifdef PARSERTEST
        return;
#else
        gFactoryRngState.seed = 0; // default seed
        gFactoryRngState.seedSave = gFactoryRngState.seed + 1; // force rnd() to call factory_fill_rnd_lookup()
#endif
}
 
void foundry_initialize_rnd_variables(void) {
#ifdef PARSERTEST
        return;
#else
        foundry_rst(691204);
#endif
}
 
void initialize_rnd_variables(void) {
#ifdef use_filterfactory_implementation_rnd
        factory_initialize_rnd_variables();
#else
        foundry_initialize_rnd_variables();
#endif

// -------------------------------------------------------------------------------------------
 
/* Direction(angle) of the current pixel from the center of the image,
   where d is an integer between -512 and 512 inclusive */
 
value_type factory_d(void) {
#ifdef PARSERTEST
        return 0;
#else
        // https://misc.daniel-marschall.de/projects/filter_factory/symbol_d_lowercase.html
 

#else
        return (value_type)RINT(TO_FFANGLE(atan2(-y, -x)));
#endif
}
 
value_type foundry_d(void) {
#ifdef PARSERTEST
        return 0;
#else
        // NOTE: FilterFactory uses c2d(x,y):=atan2(y,x), but d:=atan2(-y,-x)
        // Due to compatibility reasons, we implement it the same way!

        int y = var['Y'] / 2 - var['y'];
        return foundry_c2d_negated(x, y);
#endif
}
 
value_type ff_d(void) {
#ifdef use_filterfactory_implementation_d
        // Output range: -512 ... 512
        return factory_d();
#else
        // Output range: -511 ... 512

 
// -------------------------------------------------------------------------------------------
 
/* Range of magnitudes with the image, where M is one half the diagonal size of the image */
 
value_type factory_M(void) {
#ifdef PARSERTEST
        return 0;
#else
        // https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_uppercase.html
 

        eax += ebx;
        return eax;
#endif
}
 
value_type foundry_M(void) {
#ifdef PARSERTEST
        return 0;
#else
        return foundry_c2m(var['X'], var['Y']) / 2;
#endif
}
 
value_type ff_M(void) {
#ifdef use_filterfactory_implementation_M
        return factory_M();
#else
        return foundry_M();
#endif

 
// -------------------------------------------------------------------------------------------
 
/* Distance (magnitude) from the center of the image to the current pixel */
 
value_type factory_m(void) {
#ifdef PARSERTEST
        return 0;
#else
        // https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_lowercase.html
 

        eax += ebx;
        return eax;
#endif
}
 
value_type foundry_m(void) {
#ifdef PARSERTEST
        return 0;
#else
        return foundry_c2m(var['X'] / 2 - var['x'], var['Y'] / 2 - var['y']);
#endif
}
 
value_type ff_m(void) {
#ifdef use_filterfactory_implementation_m
        return factory_m();
#else
        return foundry_m();
#endif

 
// -------------------------------------------------------------------------------------------
 
/* "Y" value of the YUV color-space */
 
value_type factory_i(void) {
#ifdef PARSERTEST
        return 0;
#else
        return ((76L * var['r']) + (150L * var['g']) + (29L * var['b'])) / 256; // range: [0..254]
#endif
}
 
value_type foundry_i(void) {
#ifdef PARSERTEST
        return 0;
#else
        // These formulas are more accurate, e.g. pure white has now i=255 instead of 254
        return ((299L * var['r']) + (587L * var['g']) + (114L * var['b'])) / 1000;    // range: [0..255]
#endif
}
 
value_type ff_i(void) {
#ifdef use_filterfactory_implementation_i
        return factory_i();
#else
        return foundry_i();
#endif

 
// -------------------------------------------------------------------------------------------
 
/* "U" value of the YUV color-space */
 
value_type factory_u(void) {
#ifdef PARSERTEST
        return 0;
#else
        return ((-19L * var['r']) + (-37L * var['g']) + (56L * var['b'])) / 256; // range: [-55..55]
#endif
}
 
value_type foundry_u(void) {
#ifdef PARSERTEST
        return 0;
#else
        // These formulas are more accurate, e.g. pure white has now i=255 instead of 254
        return ((-147407L * var['r']) + (-289391L * var['g']) + (436798L * var['b'])) / 2000000; // range: [-55..55]
#endif
}
 
value_type ff_u(void) {
#ifdef use_filterfactory_implementation_u
        return factory_u();
#else
        return foundry_u();
#endif

 
// -------------------------------------------------------------------------------------------
 
/* "V" value of the YUV color-space */
 
value_type factory_v(void) {
#ifdef PARSERTEST
        return 0;
#else
        return ((78L * var['r']) + (-65L * var['g']) + (-13L * var['b'])) / 256; // range: [-77..77]
#endif
}
 
value_type foundry_v(void) {
#ifdef PARSERTEST
        return 0;
#else
        // These formulas are more accurate, e.g. pure white has now i=255 instead of 254
        return ((614777L * var['r']) + (-514799L * var['g']) + (-99978L * var['b'])) / 2000000; // range: [-78..78]
#endif
}
 
value_type ff_v(void) {
#ifdef use_filterfactory_implementation_v
        return factory_v();
#else
        return foundry_v();
#endif

Rev 503	Rev 532
Line 257...	Line 257...
257	extern value_type cell[], var[];	257	extern value_type cell[], var[];
258	extern unsigned char* image_ptr;	258	extern unsigned char* image_ptr;
259		259
260	// -------------------------------------------------------------------------------------------	260	// -------------------------------------------------------------------------------------------
261		261
262	void init_trigtab() {	262	void init_trigtab(void) {
263	#ifdef PARSERTEST	263	#ifdef PARSERTEST
264	return;	264	return;
265	#else	265	#else
266	int i;	266	int i;
267		267
Line 810...	Line 810...
810	#endif	810	#endif
811	}	811	}
812		812
813	// -------------------------------------------------------------------------------------------	813	// -------------------------------------------------------------------------------------------
814		814
815	void factory_initialize_rnd_variables() {	815	void factory_initialize_rnd_variables(void) {
816	#ifdef PARSERTEST	816	#ifdef PARSERTEST
817	return;	817	return;
818	#else	818	#else
819	gFactoryRngState.seed = 0; // default seed	819	gFactoryRngState.seed = 0; // default seed
820	gFactoryRngState.seedSave = gFactoryRngState.seed + 1; // force rnd() to call factory_fill_rnd_lookup()	820	gFactoryRngState.seedSave = gFactoryRngState.seed + 1; // force rnd() to call factory_fill_rnd_lookup()
821	#endif	821	#endif
822	}	822	}
823		823
824	void foundry_initialize_rnd_variables() {	824	void foundry_initialize_rnd_variables(void) {
825	#ifdef PARSERTEST	825	#ifdef PARSERTEST
826	return;	826	return;
827	#else	827	#else
828	foundry_rst(691204);	828	foundry_rst(691204);
829	#endif	829	#endif
830	}	830	}
831		831
832	void initialize_rnd_variables() {	832	void initialize_rnd_variables(void) {
833	#ifdef use_filterfactory_implementation_rnd	833	#ifdef use_filterfactory_implementation_rnd
834	factory_initialize_rnd_variables();	834	factory_initialize_rnd_variables();
835	#else	835	#else
836	foundry_initialize_rnd_variables();	836	foundry_initialize_rnd_variables();
837	#endif	837	#endif
Line 1208...	Line 1208...
1208	// -------------------------------------------------------------------------------------------	1208	// -------------------------------------------------------------------------------------------
1209		1209
1210	/* Direction(angle) of the current pixel from the center of the image,	1210	/* Direction(angle) of the current pixel from the center of the image,
1211	where d is an integer between -512 and 512 inclusive */	1211	where d is an integer between -512 and 512 inclusive */
1212		1212
1213	value_type factory_d() {	1213	value_type factory_d(void) {
1214	#ifdef PARSERTEST	1214	#ifdef PARSERTEST
1215	return 0;	1215	return 0;
1216	#else	1216	#else
1217	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_d_lowercase.html	1217	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_d_lowercase.html
1218		1218
Line 1269...	Line 1269...
1269	#else	1269	#else
1270	return (value_type)RINT(TO_FFANGLE(atan2(-y, -x)));	1270	return (value_type)RINT(TO_FFANGLE(atan2(-y, -x)));
1271	#endif	1271	#endif
1272	}	1272	}
1273		1273
1274	value_type foundry_d() {	1274	value_type foundry_d(void) {
1275	#ifdef PARSERTEST	1275	#ifdef PARSERTEST
1276	return 0;	1276	return 0;
1277	#else	1277	#else
1278	// NOTE: FilterFactory uses c2d(x,y):=atan2(y,x), but d:=atan2(-y,-x)	1278	// NOTE: FilterFactory uses c2d(x,y):=atan2(y,x), but d:=atan2(-y,-x)
1279	// Due to compatibility reasons, we implement it the same way!	1279	// Due to compatibility reasons, we implement it the same way!
Line 1282...	Line 1282...
1282	int y = var['Y'] / 2 - var['y'];	1282	int y = var['Y'] / 2 - var['y'];
1283	return foundry_c2d_negated(x, y);	1283	return foundry_c2d_negated(x, y);
1284	#endif	1284	#endif
1285	}	1285	}
1286		1286
1287	value_type ff_d() {	1287	value_type ff_d(void) {
1288	#ifdef use_filterfactory_implementation_d	1288	#ifdef use_filterfactory_implementation_d
1289	// Output range: -512 ... 512	1289	// Output range: -512 ... 512
1290	return factory_d();	1290	return factory_d();
1291	#else	1291	#else
1292	// Output range: -511 ... 512	1292	// Output range: -511 ... 512
Line 1296...	Line 1296...
1296		1296
1297	// -------------------------------------------------------------------------------------------	1297	// -------------------------------------------------------------------------------------------
1298		1298
1299	/* Range of magnitudes with the image, where M is one half the diagonal size of the image */	1299	/* Range of magnitudes with the image, where M is one half the diagonal size of the image */
1300		1300
1301	value_type factory_M() {	1301	value_type factory_M(void) {
1302	#ifdef PARSERTEST	1302	#ifdef PARSERTEST
1303	return 0;	1303	return 0;
1304	#else	1304	#else
1305	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_uppercase.html	1305	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_uppercase.html
1306		1306
Line 1326...	Line 1326...
1326	eax += ebx;	1326	eax += ebx;
1327	return eax;	1327	return eax;
1328	#endif	1328	#endif
1329	}	1329	}
1330		1330
1331	value_type foundry_M() {	1331	value_type foundry_M(void) {
1332	#ifdef PARSERTEST	1332	#ifdef PARSERTEST
1333	return 0;	1333	return 0;
1334	#else	1334	#else
1335	return foundry_c2m(var['X'], var['Y']) / 2;	1335	return foundry_c2m(var['X'], var['Y']) / 2;
1336	#endif	1336	#endif
1337	}	1337	}
1338		1338
1339	value_type ff_M() {	1339	value_type ff_M(void) {
1340	#ifdef use_filterfactory_implementation_M	1340	#ifdef use_filterfactory_implementation_M
1341	return factory_M();	1341	return factory_M();
1342	#else	1342	#else
1343	return foundry_M();	1343	return foundry_M();
1344	#endif	1344	#endif
Line 1346...	Line 1346...
1346		1346
1347	// -------------------------------------------------------------------------------------------	1347	// -------------------------------------------------------------------------------------------
1348		1348
1349	/* Distance (magnitude) from the center of the image to the current pixel */	1349	/* Distance (magnitude) from the center of the image to the current pixel */
1350		1350
1351	value_type factory_m() {	1351	value_type factory_m(void) {
1352	#ifdef PARSERTEST	1352	#ifdef PARSERTEST
1353	return 0;	1353	return 0;
1354	#else	1354	#else
1355	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_lowercase.html	1355	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_lowercase.html
1356		1356
Line 1377...	Line 1377...
1377	eax += ebx;	1377	eax += ebx;
1378	return eax;	1378	return eax;
1379	#endif	1379	#endif
1380	}	1380	}
1381		1381
1382	value_type foundry_m() {	1382	value_type foundry_m(void) {
1383	#ifdef PARSERTEST	1383	#ifdef PARSERTEST
1384	return 0;	1384	return 0;
1385	#else	1385	#else
1386	return foundry_c2m(var['X'] / 2 - var['x'], var['Y'] / 2 - var['y']);	1386	return foundry_c2m(var['X'] / 2 - var['x'], var['Y'] / 2 - var['y']);
1387	#endif	1387	#endif
1388	}	1388	}
1389		1389
1390	value_type ff_m() {	1390	value_type ff_m(void) {
1391	#ifdef use_filterfactory_implementation_m	1391	#ifdef use_filterfactory_implementation_m
1392	return factory_m();	1392	return factory_m();
1393	#else	1393	#else
1394	return foundry_m();	1394	return foundry_m();
1395	#endif	1395	#endif
Line 1397...	Line 1397...
1397		1397
1398	// -------------------------------------------------------------------------------------------	1398	// -------------------------------------------------------------------------------------------
1399		1399
1400	/* "Y" value of the YUV color-space */	1400	/* "Y" value of the YUV color-space */
1401		1401
1402	value_type factory_i() {	1402	value_type factory_i(void) {
1403	#ifdef PARSERTEST	1403	#ifdef PARSERTEST
1404	return 0;	1404	return 0;
1405	#else	1405	#else
1406	return ((76L * var['r']) + (150L * var['g']) + (29L * var['b'])) / 256; // range: [0..254]	1406	return ((76L * var['r']) + (150L * var['g']) + (29L * var['b'])) / 256; // range: [0..254]
1407	#endif	1407	#endif
1408	}	1408	}
1409		1409
1410	value_type foundry_i() {	1410	value_type foundry_i(void) {
1411	#ifdef PARSERTEST	1411	#ifdef PARSERTEST
1412	return 0;	1412	return 0;
1413	#else	1413	#else
1414	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254	1414	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
1415	return ((299L * var['r']) + (587L * var['g']) + (114L * var['b'])) / 1000; // range: [0..255]	1415	return ((299L * var['r']) + (587L * var['g']) + (114L * var['b'])) / 1000; // range: [0..255]
1416	#endif	1416	#endif
1417	}	1417	}
1418		1418
1419	value_type ff_i() {	1419	value_type ff_i(void) {
1420	#ifdef use_filterfactory_implementation_i	1420	#ifdef use_filterfactory_implementation_i
1421	return factory_i();	1421	return factory_i();
1422	#else	1422	#else
1423	return foundry_i();	1423	return foundry_i();
1424	#endif	1424	#endif
Line 1426...	Line 1426...
1426		1426
1427	// -------------------------------------------------------------------------------------------	1427	// -------------------------------------------------------------------------------------------
1428		1428
1429	/* "U" value of the YUV color-space */	1429	/* "U" value of the YUV color-space */
1430		1430
1431	value_type factory_u() {	1431	value_type factory_u(void) {
1432	#ifdef PARSERTEST	1432	#ifdef PARSERTEST
1433	return 0;	1433	return 0;
1434	#else	1434	#else
1435	return ((-19L * var['r']) + (-37L * var['g']) + (56L * var['b'])) / 256; // range: [-55..55]	1435	return ((-19L * var['r']) + (-37L * var['g']) + (56L * var['b'])) / 256; // range: [-55..55]
1436	#endif	1436	#endif
1437	}	1437	}
1438		1438
1439	value_type foundry_u() {	1439	value_type foundry_u(void) {
1440	#ifdef PARSERTEST	1440	#ifdef PARSERTEST
1441	return 0;	1441	return 0;
1442	#else	1442	#else
1443	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254	1443	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
1444	return ((-147407L * var['r']) + (-289391L * var['g']) + (436798L * var['b'])) / 2000000; // range: [-55..55]	1444	return ((-147407L * var['r']) + (-289391L * var['g']) + (436798L * var['b'])) / 2000000; // range: [-55..55]
1445	#endif	1445	#endif
1446	}	1446	}
1447		1447
1448	value_type ff_u() {	1448	value_type ff_u(void) {
1449	#ifdef use_filterfactory_implementation_u	1449	#ifdef use_filterfactory_implementation_u
1450	return factory_u();	1450	return factory_u();
1451	#else	1451	#else
1452	return foundry_u();	1452	return foundry_u();
1453	#endif	1453	#endif
Line 1455...	Line 1455...
1455		1455
1456	// -------------------------------------------------------------------------------------------	1456	// -------------------------------------------------------------------------------------------
1457		1457
1458	/* "V" value of the YUV color-space */	1458	/* "V" value of the YUV color-space */
1459		1459
1460	value_type factory_v() {	1460	value_type factory_v(void) {
1461	#ifdef PARSERTEST	1461	#ifdef PARSERTEST
1462	return 0;	1462	return 0;
1463	#else	1463	#else
1464	return ((78L * var['r']) + (-65L * var['g']) + (-13L * var['b'])) / 256; // range: [-77..77]	1464	return ((78L * var['r']) + (-65L * var['g']) + (-13L * var['b'])) / 256; // range: [-77..77]
1465	#endif	1465	#endif
1466	}	1466	}
1467		1467
1468	value_type foundry_v() {	1468	value_type foundry_v(void) {
1469	#ifdef PARSERTEST	1469	#ifdef PARSERTEST
1470	return 0;	1470	return 0;
1471	#else	1471	#else
1472	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254	1472	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
1473	return ((614777L * var['r']) + (-514799L * var['g']) + (-99978L * var['b'])) / 2000000; // range: [-78..78]	1473	return ((614777L * var['r']) + (-514799L * var['g']) + (-99978L * var['b'])) / 2000000; // range: [-78..78]
1474	#endif	1474	#endif
1475	}	1475	}
1476		1476
1477	value_type ff_v() {	1477	value_type ff_v(void) {
1478	#ifdef use_filterfactory_implementation_v	1478	#ifdef use_filterfactory_implementation_v
1479	return factory_v();	1479	return factory_v();
1480	#else	1480	#else
1481	return foundry_v();	1481	return foundry_v();
1482	#endif	1482	#endif

Subversion Repositories filter_foundry

filter_foundry/trunk/funcs.c – Rev 503 → 532