~azzar1/unity/add-show-desktop-key

$weight = (abs($this->basis_matrix[$this->x][1]) - abs($this->basis_matrix[$this->x][0])) + (abs($this->basis_matrix[$this->y][0]) - abs($this->basis_matrix[$this->y][1]));

861

862

// Swap "x" with "y"

863

if ($weight > 0)

864

{

865

list($this->x, $this->y) = array($this->y, $this->x);

866

}

867

868

$this->abs_x = array($this->basis_matrix[$this->x][0], $this->basis_matrix[$this->x][1]);

869

$this->abs_y = array($this->basis_matrix[$this->y][0], $this->basis_matrix[$this->y][1]);

870

871

if ($this->abs_x[0] < 0)

872

{

873

$this->abs_x[0] *= -1;

874

$this->abs_x[1] *= -1;

875

}

876

877

if ($this->abs_y[1] > 0)

878

{

879

$this->abs_y[0] *= -1;

880

$this->abs_y[1] *= -1;

881

}

882

883

$this->letter = $letter;

884

}

885

886

/**

887

* Draw a character

888

889

function drawchar($scale, $xoff, $yoff, $img, $background, $colours)

890

{

891

$width = $this->bitmap_width;

892

$height = $this->bitmap_height;

893

$bitmap = $this->bitmap;

894

895

$colour1 = $colours[array_rand($colours)];

896

$colour2 = $colours[array_rand($colours)];

897

898

$swapx = ($this->basis_matrix[$this->x][0] > 0);

899

$swapy = ($this->basis_matrix[$this->y][1] < 0);

900

901

for ($y = 0; $y < $height; ++$y)

902

{

903

for ($x = 0; $x < $width; ++$x)

904

{

905

$xp = ($swapx) ? ($width - $x - 1) : $x;

906

$yp = ($swapy) ? ($height - $y - 1) : $y;

907

908

if ($bitmap[$height - $yp - 1][$xp])

909

{

910

$dx = $this->scale($this->abs_x, ($xp - ($swapx ? ($width / 2) : ($width / 2) - 1)) * $scale);

911

$dy = $this->scale($this->abs_y, ($yp - ($swapy ? ($height / 2) : ($height / 2) - 1)) * $scale);

912

$xo = $xoff + $dx[0] + $dy[0];

913

$yo = $yoff + $dx[1] + $dy[1];

914

915

$origin = array(0, 0, 0);

916

$xvec = $this->scale($this->basis_matrix[$this->x], $scale);

917

$yvec = $this->scale($this->basis_matrix[$this->y], $scale);

918

$face_corner = $this->sum2($xvec, $yvec);

919

920

$zvec = $this->scale($this->basis_matrix[$this->z], $scale);

921

$x_corner = $this->sum2($xvec, $zvec);

922

$y_corner = $this->sum2($yvec, $zvec);

923

924

imagefilledpolygon($img, $this->gen_poly($xo, $yo, $origin, $xvec, $x_corner,$zvec), 4, $colour1);

925

imagefilledpolygon($img, $this->gen_poly($xo, $yo, $origin, $yvec, $y_corner,$zvec), 4, $colour2);

926

927

$face = $this->gen_poly($xo, $yo, $origin, $xvec, $face_corner, $yvec);

928

929

imagefilledpolygon($img, $face, 4, $background);

930

imagepolygon($img, $face, 4, $colour1);

931

}

932

}

933

}

934

}

935

936

937

* return a roughly acceptable range of sizes for rendering with this texttype

938

939

function range()

940

{

941

return array(3, 4);

942

}

943

944

/**

945

* Vector length

946

947

function vectorlen($vector)

948

{

949

return sqrt(pow($vector[0], 2) + pow($vector[1], 2) + pow($vector[2], 2));

950

}

951

952

/**

953

* Normalize

954

955

function normalize(&$vector, $length = 1)

956

{

957

$length = (( $length < 1) ? 1 : $length);

958

$length /= $this->vectorlen($vector);

959

$vector[0] *= $length;

960

$vector[1] *= $length;

961

$vector[2] *= $length;

962

}

963

964

/**

965

966

function cross_product($vector1, $vector2)

967

{

968

$retval = array(0, 0, 0);

969

$retval[0] = (($vector1[1] * $vector2[2]) - ($vector1[2] * $vector2[1]));

970

$retval[1] = -(($vector1[0] * $vector2[2]) - ($vector1[2] * $vector2[0]));

971

$retval[2] = (($vector1[0] * $vector2[1]) - ($vector1[1] * $vector2[0]));

972

973

return $retval;

974

}

975

976

/**

977

978

function sum($vector1, $vector2)

979

{

980

return array($vector1[0] + $vector2[0], $vector1[1] + $vector2[1], $vector1[2] + $vector2[2]);

981

}

982

983

/**

984

985

function sum2($vector1, $vector2)

986

{

987

return array($vector1[0] + $vector2[0], $vector1[1] + $vector2[1]);

988

}

989

990

/**

991

992

function scale($vector, $length)

993

{

994

if (sizeof($vector) == 2)

995

{

996

return array($vector[0] * $length, $vector[1] * $length);

997

}

998

999

return array($vector[0] * $length, $vector[1] * $length, $vector[2] * $length);

1000

}

1001

1002

/**

1003

1004

function gen_poly($xoff, $yoff, &$vec1, &$vec2, &$vec3, &$vec4)

1005

{

1006

$poly = array();

1007

$poly[0] = $xoff + $vec1[0];

1008

$poly[1] = $yoff + $vec1[1];

1009

$poly[2] = $xoff + $vec2[0];

1010

$poly[3] = $yoff + $vec2[1];

1011

$poly[4] = $xoff + $vec3[0];

1012

$poly[5] = $yoff + $vec3[1];

1013

$poly[6] = $xoff + $vec4[0];

1014

$poly[7] = $yoff + $vec4[1];

1015

1016

return $poly;

1017

}

1018

1019

/**

1020

* dimensions

1021

1022

function dimensions($size)

1023

{

1024

$xn = $this->scale($this->basis_matrix[$this->x], -($this->bitmap_width / 2) * $size);

1025

$xp = $this->scale($this->basis_matrix[$this->x], ($this->bitmap_width / 2) * $size);

1026

$yn = $this->scale($this->basis_matrix[$this->y], -($this->bitmap_height / 2) * $size);

1027

$yp = $this->scale($this->basis_matrix[$this->y], ($this->bitmap_height / 2) * $size);

1028

1029

$p = array();

1030

$p[0] = $this->sum2($xn, $yn);

1031

$p[1] = $this->sum2($xp, $yn);

1032

$p[2] = $this->sum2($xp, $yp);

1033

$p[3] = $this->sum2($xn, $yp);

1034

1035

$min_x = $max_x = $p[0][0];

1036

$min_y = $max_y = $p[0][1];

1037

1038

for ($i = 1; $i < 4; ++$i)

1039

{

1040

$min_x = ($min_x > $p[$i][0]) ? $p[$i][0] : $min_x;

1041

$min_y = ($min_y > $p[$i][1]) ? $p[$i][1] : $min_y;

1042

$max_x = ($max_x < $p[$i][0]) ? $p[$i][0] : $max_x;

1043

$max_y = ($max_y < $p[$i][1]) ? $p[$i][1] : $max_y;

1044

}

1045

1046

return array($min_x, $min_y, $max_x, $max_y);

1047

}

1048

}

1049

1050

/**

1051

* @package VC

1052

1053

class colour_manager

1054

{

1055

var $img;

1056

var $mode;

1057

var $colours;

1058

var $named_colours;

1059

1060

/**

1061

* Create the colour manager, link it to the image resource

1062

1063

function colour_manager($img, $background = false, $mode = 'ahsv')

1064

{

1065

$this->img = $img;

1066

$this->mode = $mode;

1067

$this->colours = array();

1068

$this->named_colours = array();

1069

1070

if ($background !== false)

1071

{

1072

$bg = $this->allocate_named('background', $background);

1073

imagefill($this->img, 0, 0, $bg);

1074

}

1075

}

1076

1077

/**

1078

* Lookup a named colour resource

1079

1080

function get_resource($named_colour)

1081

{

1082

if (isset($this->named_colours[$named_colour]))

1083

{

1084

return $this->named_colours[$named_colour];

1085

}

1086

1087

if (isset($this->named_rgb[$named_colour]))

1088

{

1089

return $this->allocate_named($named_colour, $this->named_rgb[$named_colour], 'rgb');

1090

}

1091

1092

return false;

1093

}

1094

1095

/**

1096

* Assign a name to a colour resource

1097

1098

function name_colour($name, $resource)

1099

{

1100

$this->named_colours[$name] = $resource;

1101

}

1102

1103

/**

1104

* names and allocates a colour resource

1105

1106

function allocate_named($name, $colour, $mode = false)

1107

{

1108

$resource = $this->allocate($colour, $mode);

1109

1110

if ($resource !== false)

1111

{

1112

$this->name_colour($name, $resource);

1113

}

1114

return $resource;

1115

}

1116

1117

/**

1118

* allocates a specified colour into the image

1119

1120

function allocate($colour, $mode = false)

1121

{

1122

if ($mode === false)

1123

{

1124

$mode = $this->mode;

1125

}

1126

1127

if (!is_array($colour))

1128

{

1129

if (isset($this->named_rgb[$colour]))

1130

{

1131

return $this->allocate_named($colour, $this->named_rgb[$colour], 'rgb');

1132

}

1133

1134

if (!is_int($colour))

1135

{

1136

return false;

1137

}

1138

1139

$mode = 'rgb';

1140

$colour = array(255 & ($colour >> 16), 255 & ($colour >> 8), 255 & $colour);

1141

}

1142

1143

if (isset($colour['mode']))

1144

{

1145

$mode = $colour['mode'];

1146

unset($colour['mode']);

1147

}

1148

1149

if (isset($colour['random']))

1150

{

1151

unset($colour['random']);

1152

// everything else is params

1153

return $this->random_colour($colour, $mode);

1154

}

1155

1156

$rgb = colour_manager::model_convert($colour, $mode, 'rgb');

1157

$store = ($this->mode == 'rgb') ? $rgb : colour_manager::model_convert($colour, $mode, $this->mode);

1158

$resource = imagecolorallocate($this->img, $rgb[0], $rgb[1], $rgb[2]);

1159

$this->colours[$resource] = $store;

1160

1161

return $resource;

1162

}

1163

1164

/**

1165

* randomly generates a colour, with optional params

1166

1167

function random_colour($params = array(), $mode = false)

1168

{

1169

if ($mode === false)

1170

{

1171

$mode = $this->mode;

1172

}

1173

1174

switch ($mode)

1175

{

1176

case 'rgb':

1177

// @TODO random rgb generation. do we intend to do this, or is it just too tedious?

1178

break;

1179

1180

case 'ahsv':

1181

case 'hsv':

1182

default:

1183

1184

$default_params = array(

1185

'hue_bias' => false, // degree / 'r'/'g'/'b'/'c'/'m'/'y' /'o'

1186

'hue_range' => false, // if hue bias, then difference range +/- from bias

1187

'min_saturation' => 30, // 0 - 100

1188

'max_saturation' => 80, // 0 - 100

1189

'min_value' => 30, // 0 - 100

1190

'max_value' => 80, // 0 - 100

1191

);

1192

1193

$alt = ($mode == 'ahsv') ? true : false;

1194

$params = array_merge($default_params, $params);

1195

1196

$min_hue = 0;

1197

$max_hue = 359;

1198

$min_saturation = max(0, $params['min_saturation']);

1199

$max_saturation = min(100, $params['max_saturation']);

1200

$min_value = max(0, $params['min_value']);

1201

$max_value = min(100, $params['max_value']);

1202

1203

if ($params['hue_bias'] !== false)

1204

{

1205

if (is_numeric($params['hue_bias']))

1206

{

1207

$h = intval($params['hue_bias']) % 360;

1208

}

1209

else

1210

{

1211

switch ($params['hue_bias'])

1212

{

1213

case 'o':

1214

$h = $alt ? 60 : 30;

1215

break;

1216

1217

case 'y':

1218

$h = $alt ? 120 : 60;

1219

break;

1220

1221

case 'g':

1222

$h = $alt ? 180 : 120;

1223

break;

1224

1225

case 'c':

1226

$h = $alt ? 210 : 180;

1227

break;

1228

1229

case 'b':

1230

$h = 240;

1231

break;

1232

1233

case 'm':

1234

$h = 300;

1235

break;

1236

1237

case 'r':

1238

default:

1239

$h = 0;

1240

break;

1241

}

1242

}

1243

1244

$min_hue = $h + 360;

1245

$max_hue = $h + 360;

1246

1247

if ($params['hue_range'])

1248

{

1249

$min_hue -= min(180, $params['hue_range']);

1250

$max_hue += min(180, $params['hue_range']);

1251

}

1252

}

1253

1254

$h = mt_rand($min_hue, $max_hue);

1255

$s = mt_rand($min_saturation, $max_saturation);

1256

$v = mt_rand($min_value, $max_value);

1257

1258

return $this->allocate(array($h, $s, $v), $mode);

1259

1260

break;

1261

}

1262

}

1263

1264

/**

1265

1266

function colour_scheme($resource, $include_original = true)

1267

{

1268

$mode = 'hsv';

1269

1270

if (($pre = $this->get_resource($resource)) !== false)

1271

{

1272

$resource = $pre;

1273

}

1274

1275

$colour = colour_manager::model_convert($this->colours[$resource], $this->mode, $mode);

1276

$results = ($include_original) ? array($resource) : array();

1277

$colour2 = $colour3 = $colour4 = $colour;

1278

$colour2[0] += 150;

1279

$colour3[0] += 180;

1280

$colour4[0] += 210;

1281

1282

1283

$results[] = $this->allocate($colour2, $mode);

1284

$results[] = $this->allocate($colour3, $mode);

1285

$results[] = $this->allocate($colour4, $mode);

1286

1287

return $results;

1288

}

1289

1290

/**

1291

1292

function mono_range($resource, $count = 5, $include_original = true)

1293

{

1294

if (is_array($resource))

1295

{

1296

$results = array();

1297

for ($i = 0, $size = sizeof($resource); $i < $size; ++$i)

1298

{

1299

$results = array_merge($results, $this->mono_range($resource[$i], $count, $include_original));

1300

}

1301

return $results;

1302

}

1303

1304

$mode = (in_array($this->mode, array('hsv', 'ahsv'), true) ? $this->mode : 'ahsv');

1305

if (($pre = $this->get_resource($resource)) !== false)

1306

{

1307

$resource = $pre;

1308

}

1309

1310

$colour = colour_manager::model_convert($this->colours[$resource], $this->mode, $mode);

1311

1312

$results = array();

1313

if ($include_original)

1314

{

1315

$results[] = $resource;

1316

$count--;

1317

}

1318

1319

// This is a hard problem. I chicken out and try to maintain readability at the cost of less randomness.

1320

1321

while ($count > 0)

1322

{

1323

$colour[1] = ($colour[1] + mt_rand(40,60)) % 99;

1324

$colour[2] = ($colour[2] + mt_rand(40,60));

1325

$results[] = $this->allocate($colour, $mode);

1326

$count--;

1327

}

1328

return $results;

1329

}

1330

1331

/**

1332

* Convert from one colour model to another

1333

1334

function model_convert($colour, $from_model, $to_model)

1335

{

1336

if ($from_model == $to_model)

1337

{

1338

return $colour;

1339

}

1340

1341

switch ($to_model)

1342

{

1343

case 'hsv':

1344

1345

switch ($from_model)

1346

{

1347

case 'ahsv':

1348

return colour_manager::ah2h($colour);

1349

break;

1350

1351

case 'rgb':

1352

return colour_manager::rgb2hsv($colour);

1353

break;

1354

}

1355

break;

1356

1357

case 'ahsv':

1358

1359

switch ($from_model)

1360

{

1361

case 'hsv':

1362

return colour_manager::h2ah($colour);

1363

break;

1364

1365

case 'rgb':

1366

return colour_manager::h2ah(colour_manager::rgb2hsv($colour));

1367

break;

1368

}

1369

break;

1370

1371

case 'rgb':

1372

switch ($from_model)

1373

{

1374

case 'hsv':

1375

return colour_manager::hsv2rgb($colour);

1376

break;

1377

1378

case 'ahsv':

1379

return colour_manager::hsv2rgb(colour_manager::ah2h($colour));

1380

break;

1381

}

1382

break;

1383

}

1384

return false;

1385

}

1386

1387

/**

1388

* Slightly altered from wikipedia's algorithm

1389

1390

function hsv2rgb($hsv)

1391

{

1392

colour_manager::normalize_hue($hsv[0]);

1393

1394

$h = $hsv[0];

1395

$s = min(1, max(0, $hsv[1] / 100));

1396

$v = min(1, max(0, $hsv[2] / 100));

1397

1398

// calculate hue sector

1399

$hi = floor($hsv[0] / 60);

1400

1401

// calculate opposite colour

1402

$p = $v * (1 - $s);

1403

1404

// calculate distance between hex vertices

1405

$f = ($h / 60) - $hi;

1406

1407

// coming in or going out?

1408

if (!($hi & 1))

1409

{

1410

$f = 1 - $f;

1411

}

1412

1413

// calculate adjacent colour

1414

$q = $v * (1 - ($f * $s));

1415

1416

switch ($hi)

1417

{

1418

case 0:

1419

$rgb = array($v, $q, $p);

1420

break;

1421

1422

case 1:

1423

$rgb = array($q, $v, $p);

1424

break;

1425

1426

case 2:

1427

$rgb = array($p, $v, $q);

1428

break;

1429

1430

case 3:

1431

$rgb = array($p, $q, $v);

1432

break;

1433

1434

case 4:

1435

$rgb = array($q, $p, $v);

1436

break;

1437

1438

case 5:

1439

$rgb = array($v, $p, $q);

1440

break;

1441

1442

default:

1443

return array(0, 0, 0);

1444

break;

1445

}

1446

1447

return array(255 * $rgb[0], 255 * $rgb[1], 255 * $rgb[2]);

1448

}

1449

1450

/**

1451

* (more than) Slightly altered from wikipedia's algorithm

1452

1453

function rgb2hsv($rgb)

1454

{

1455

$r = min(255, max(0, $rgb[0]));

1456

$g = min(255, max(0, $rgb[1]));

1457

$b = min(255, max(0, $rgb[2]));

1458

$max = max($r, $g, $b);

1459

$min = min($r, $g, $b);

1460

1461

$v = $max / 255;

1462

$s = (!$max) ? 0 : 1 - ($min / $max);

1463

1464

// if max - min is 0, we want hue to be 0 anyway.

1465

$h = $max - $min;

1466

1467

if ($h)

1468

{

1469

switch ($max)

1470

{

1471

case $g:

1472

$h = 120 + (60 * ($b - $r) / $h);

1473

break;

1474

1475

case $b:

1476

$h = 240 + (60 * ($r - $g) / $h);

1477

break;

1478

1479

case $r:

1480

$h = 360 + (60 * ($g - $b) / $h);

1481

break;

1482

}

1483

}

1484

colour_manager::normalize_hue($h);

1485

1486

return array($h, $s * 100, $v * 100);

1487

}

1488

1489

/**

1490

1491

function normalize_hue(&$hue)

1492

{

1493

$hue %= 360;

1494

1495

if ($hue < 0)

1496

{

1497

$hue += 360;

1498

}

1499

}

1500

1501

/**

1502

* Alternate hue to hue

1503

1504

function ah2h($ahue)

1505

{

1506

if (is_array($ahue))

1507

{

1508

$ahue[0] = colour_manager::ah2h($ahue[0]);

1509

return $ahue;

1510

}

1511

colour_manager::normalize_hue($ahue);

1512

1513

// blue through red is already ok

1514

if ($ahue >= 240)

1515

{

1516

return $ahue;

1517

}

1518

1519

// ahue green is at 180

1520

if ($ahue >= 180)

1521

{

1522

// return (240 - (2 * (240 - $ahue)));

1523

return (2 * $ahue) - 240; // equivalent

1524

}

1525

1526

// ahue yellow is at 120 (RYB rather than RGB)

1527

if ($ahue >= 120)

1528

{

1529

return $ahue - 60;

1530

}

1531

1532

return $ahue / 2;

1533

}

1534

1535

/**

1536

* hue to Alternate hue

1537

1538

function h2ah($hue)

1539

{

1540

if (is_array($hue))

1541

{

1542

$hue[0] = colour_manager::h2ah($hue[0]);

1543

return $hue;

1544

}

1545

colour_manager::normalize_hue($hue);

1546

1547

// blue through red is already ok

1548

if ($hue >= 240)

1549

{

1550

return $hue;

1551

}

1552

else if ($hue <= 60)

1553

{

1554

return $hue * 2;

1555

}

1556

else if ($hue <= 120)

1557

{

1558

return $hue + 60;

1559

}

1560

else

1561

{

1562

return ($hue + 240) / 2;

1563

}

1564

}

1565

}

1566

1567

b'\\ No newline at end of file'

Older »