1
2
3
4
5
6
7
8
9
10
11

textarea{
        height:300px;
        width:400px;
        max-height:300px;
        max-width:400px;
    }

1
2
3
4
5
6
7
8
9

textarea{
        height:300px;
        width:400px;
        resize:none;
    }

1
2
3
4
5
6
7
8
9

textarea{
        height:300px;
        width:400px;
        resize:horizontal;
    }

1
2
3
4
5
6
7
8
9

textarea{
        height:300px;
        width:400px;
        resize:vertical;
    }

1
2
3
4
5
6
7
8
9
10
11

-webkit-transform:rotate(-180deg);
-moz-transform:rotate(-180deg);
-o-transform:rotate(-180deg);
transform:rotate(-180deg);
ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";
filter:progid:DXImageTransform.Microsoft.BasicImage(rotation=2);

1
2
3

direction: rtl;
unicode-bidi: bidi-override;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

function imagesharpen( $image) {

        $matrix = array(
            array(-1, -1, -1),
            array(-1, 16, -1),
            array(-1, -1, -1),
        );

        $divisor = array_sum(array_map('array_sum', $matrix));
        $offset = 0;
        imageconvolution($image, $matrix, $divisor, $offset);

        return $image;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

<?php  

    function GDThrowError($message)
    {
        // don't throw plain text errors in a function that's supposed to return an image

        // as per "the principle of least astonishment": the user is expecting

        // a jpeg, and they'll be less astonished to get a JPEG error message

        // than they would be if they got plain text.  Imagine this was called

        // from an image tag, which makes sense, that's how you use images:

        // plain text errors won't even reach most users, they'd have to copy

        // the img src into the address bar.  It probably wont' even occur to

        // them, as it's not typically helpful to view the source of an image

        // resource.

        $font = 2;
        // create a canvas with a bit of padding

        $errimg = imagecreate((imagefontwidth($font) * strlen($message)) + 20, imagefontheight($font) + 10);
        $bg = imagecolorallocate($errimg, 255, 255, 255);
        $textcol = imagecolorallocate($errimg, 0, 0, 0);
        imagestring($errimg, 2, 10, 5, $message, $textcol);
        header('Content-type: image/jpeg');
        imagejpeg($errimg);
        imagedestroy($errimg);
    } 

    function GDMakeJpegLookLikeCrap($target)
    {
        // image dimensions are no longer needed (see below), but getimagesize can do some simple validation

        if (($dims = @getimagesize($target)) === false || $dims['mime'] != 'image/jpeg')
        {
            GDThrowError('The file you specified couldn\'t be found or is not a valid jpeg image.  Make sure you spelled it correctly and provided the correct path.');
           return(false);
        }
        // the original function creates a new image and resamples the source to it using the same height and width here.

        // I imagine this was to add future resizing functionality but as it is it does nothing but waste resources

        $image = imagecreatefromjpeg($target);
        // don't really know/care what this is.  If you're interested see http://us2.php.net/imageconvolution

        // try tweaking these three vars for different effects, but there is a sharpening function in the php docs (above links) and it's not a trivial operation

        $spnMatrix = array( array(-1,-1,-1,),
                            array(-1,16,-1,),
                            array(-1,-1,-1));
        $divisor = 8;
        $offset = 0;
        imageconvolution($image, $spnMatrix, $divisor, $offset);
        // I like to send headers as late as possible to avoid already sent errors and duplicate header content

        header('Content-type: image/jpeg');
        imagejpeg($image, null, 100);
        imagedestroy($image);
} 

// example call

$s_image = (isset($_GET['image'])) ? $_GET['image'] : null; 

if (preg_match('/\.(jpg|jpeg)$/i', $s_image))
{
    GDMakeJpegLookLikeCrap($s_image);
}
else
{
    GDThrowError('Please specify a jpeg file to sharpen in the form: ' . $_SERVER['PHP_SELF'] . '?image=filename.jpg');
}
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

<?php
    function imagepgm($image, $filename = null)
    {
        $pgm = "P5 ".imagesx($image)." ".imagesy($image)." 255\n";
        for($y = 0; $y < imagesy($image); $y++)
        {
            for($x = 0; $x < imagesx($image); $x++)
            {
                $colors = imagecolorsforindex($image, imagecolorat($image, $x, $y));
                $pgm .= chr(0.3 * $colors["red"] + 0.59 * $colors["green"] + 0.11 * $colors["blue"]);
            }
        }
        if($filename != null)
        {
            $fp = fopen($filename, "w");
            fwrite($fp, $pgm);
            fclose($fp);
        }
        else
        {
            return $pgm;
        }
    }
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

<?php
   // replace with your files

    $originalFileName    = $filename;
    $destinationFileName = "2".$filename;

    // create a copy of the original image

    // works with jpg images

    // fell free to adapt to other formats 

    $fullPath = explode(".",$originalFileName);
    $lastIndex = sizeof($fullPath) - 1;
    $extension = $fullPath[$lastIndex];
    if (preg_match("/jpg|jpeg|JPG|JPEG/", $extension))
    {
        $sourceImage = imagecreatefromjpeg($originalFileName);
    }

    // get image dimensions

    $img_width  = imageSX($sourceImage);
    $img_height = imageSY($sourceImage);

    // convert to grayscale

    // note: this will NOT affect your original image, unless

    // originalFileName and destinationFileName are the same

    for ($y = 0; $y <$img_height; $y++)
    {
        for ($x = 0; $x <$img_width; $x++)
        {
            $rgb = imagecolorat($sourceImage, $x, $y);
            $red   = ($rgb >> 16) & 0xFF;
            $green = ($rgb >> 8)  & 0xFF;
            $blue  = $rgb & 0xFF;

          //sepia

            $red2 = min($red*.393 + $green*.769 + $blue*.189,255);
            $green2 = min($red*.349 + $green*.686 + $blue*.168,255);
            $blue2  = min($red*.272 + $green*.534 + $blue*.131,255);
            // shift gray level to the left


            $grayR = $red2 << 16;   // R: red

            $grayG = $green2 << 8 ;    // G: green

            $grayB = $blue2;         // B: blue


            // OR operation to compute gray value

            $grayColor = $grayR | $grayG | $grayB;

            // set the pixel color

            imagesetpixel ($sourceImage, $x, $y, $grayColor);
            imagecolorallocate ($sourceImage, $gray, $gray, $gray);
        }
    }

    // copy pixel values to new file buffer

    $destinationImage = ImageCreateTrueColor($img_width, $img_height);
    imagecopy($destinationImage, $sourceImage, 0, 0, 0, 0, $img_width, $img_height);

    // create file on disk

    imagejpeg($destinationImage, $destinationFileName);

    // destroy temp image buffers

    imagedestroy($destinationImage);
    imagedestroy($sourceImage);
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

<?php
function imagereflection($src_img) {
  $src_height = imagesy($src_img);
  $src_width = imagesx($src_img);
  $dest_height = $src_height + ($src_height / 2);
  $dest_width = $src_width;

  $reflected = imagecreatetruecolor($dest_width, $dest_height);
  imagealphablending($reflected, false);
  imagesavealpha($reflected, true);

  imagecopy($reflected, $src_img, 0, 0, 0, 0, $src_width, $src_height);
  $reflection_height = $src_height / 2;
  $alpha_step = 80 / $reflection_height;
  for ($y = 1; $y <= $reflection_height; $y++) {
    for ($x = 0; $x < $dest_width; $x++) {
      // copy pixel from x / $src_height - y to x / $src_height + y

      $rgba = imagecolorat($src_img, $x, $src_height - $y);
      $alpha = ($rgba & 0x7F000000) >> 24;
      $alpha =  max($alpha, 47 + ($y * $alpha_step));
      $rgba = imagecolorsforindex($src_img, $rgba);
      $rgba = imagecolorallocatealpha($reflected, $rgba['red'], $rgba['green'], $rgba['blue'], $alpha);
      imagesetpixel($reflected, $x, $src_height + $y - 1, $rgba);
    }
  }

  return $reflected;
}
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<?php
$string = 'Your Text';
$font_size = 2;
$img = imagecreate(20,90);
$bg = imagecolorallocate($img,225,225,225);
$black = imagecolorallocate($img,0,0,0);

$len = strlen($string);
for ($i=1; $i<=$len; $i++) {
    imagecharup($img, $font_size, 5, imagesy($img)-($i*imagefontwidth($font_size)), $string, $black);
    $string = substr($string,1);
}
header('Content-type: image/png');
imagepng($img);
imagedestroy($img);
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

<?php
function imagelogo (&$dst_image, $src_image, $dst_w, $dst_h, $src_w, $src_h, $position='bottom-left') {
    imagealphablending($dst_image,true);
    imagealphablending($src_image,true);
    if ($position == 'random') {
        $position = rand(1,8);
    }
    switch ($position) {
        case 'top-right':
        case 'right-top':
        case 1:
            imagecopy($dst_image, $src_image, ($dst_w-$src_w), 0, 0, 0, $src_w, $src_h);
        break;
        case 'top-left':
        case 'left-top':
        case 2:
            imagecopy($dst_image, $src_image, 0, 0, 0, 0, $src_w, $src_h);
        break;
        case 'bottom-right':
        case 'right-bottom':
        case 3:
            imagecopy($dst_image, $src_image, ($dst_w-$src_w), ($dst_h-$src_h), 0, 0, $src_w, $src_h);
        break;
        case 'bottom-left':
        case 'left-bottom':
        case 4:
            imagecopy($dst_image, $src_image, 0 , ($dst_h-$src_h), 0, 0, $src_w, $src_h);
        break;
        case 'center':
        case 5:
            imagecopy($dst_image, $src_image, (($dst_w/2)-($src_w/2)), (($dst_h/2)-($src_h/2)), 0, 0, $src_w, $src_h);
        break;
        case 'top':
        case 6:
            imagecopy($dst_image, $src_image, (($dst_w/2)-($src_w/2)), 0, 0, 0, $src_w, $src_h);
        break;
        case 'bottom':
        case 7:
            imagecopy($dst_image, $src_image, (($dst_w/2)-($src_w/2)), ($dst_h-$src_h), 0, 0, $src_w, $src_h);
        break;
        case 'left':
        case 8:
            imagecopy($dst_image, $src_image, 0, (($dst_h/2)-($src_h/2)), 0, 0, $src_w, $src_h);
        break;
        case 'right':
        case 9:
            imagecopy($dst_image, $src_image, ($dst_w-$src_w), (($dst_h/2)-($src_h/2)), 0, 0, $src_w, $src_h);
        break;
    }
} 

// example:


imagelogo($image, $watermark, imagesx($image), imagesy($image), imagesx($watermark), imagesy($watermark), 'random');
?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

<?php

function transparentImage($src){  //making images with white bg transparent

$r1=80;
$g1=80;
$b1=80;
for($x = 0; $x < imagesx($src); ++$x)
        {
            for($y = 0; $y < imagesy($src); ++$y)
            {
                $color=imagecolorat($src, $x, $y);
                $r = ($color >> 16) & 0xFF;
                $g = ($color >> 8) & 0xFF;
                $b = $color & 0xFF;
                for($i=0;$i<270;$i++){
                    if($r.$g.$b==($r1+$i).($g1+$i).($b1+$i)){
                        $trans_colour = imagecolorallocatealpha($src, 0, 0, 0, 127);
                        imagefill($src, $x, $y, $trans_colour);
                    }
                }
            }
        }

        return $src;
}

$image='abc/abc.jpg';
$src = imagecreatefromjpeg($image);
$src=transparentImage($src); //Lets make the jpegs transparent


?>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

<?php
/**
* $image image cursor (from imagecreatetruecolor)
* $backgound image curosr (from imagecolorallocate)
* $paddng int
*/
function imageCrop($image, $background = false, $padding = 0) {
    if($background)
      $background = imagecolorallocate($image, 255, 255, 255); 

    $top = imageSY($image);
    $left = imageSX($image);
    $bottom = 0;
    $right = 0; 

    for ($x = 0 ; $x < imagesx($image) ; $x++) {
        for ($y = 0 ; $y < imagesy($image) ; $y++) { 

          // if there match

            if(imagecolorat($image, $x, $y) != $background) { 

              if($x < $left)
                $left = $x;
              if($x > $right)
                $right = $x;
              if($y > $bottom)
                $bottom = $y;
              if($y < $top)
                $top = $y;
        }
        }
    } 

    $right++;
    $bottom++; 

    // create new image with padding

    $img = imagecreatetruecolor($right-$left+$padding*2,$bottom-$top+$padding*2);
    // fill the background

    imagefill($img, 0, 0, $background);
    // copy

    imagecopy($img, $image, $padding, $padding, $left, $top, $right-$left, $bottom-$top); 

    // destroy old image cursor

    imagedestroy($image);
    return $img;
}
?>

1
2
3
4
5
6
7
8
9
10
11

opacity: 0.6;
-webkit-transition: all 1s ease-out;
-moz-transition: all 1s ease-out;
-o-transition: all 1s ease-out;
-ms-transition: all 1s ease-out;
transition: all 1s ease-out;

1
2
3
4
5
6
7
8
9
10
11

opacity: 1;
-webkit-transition: all 1s ease-out;
-moz-transition: all 1s ease-out;
-o-transition: all 1s ease-out;
-ms-transition: all 1s ease-out;
transition: all 1s ease-out;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<script type="text/javascript">
$(document).ready(function() {
$('body').find('img').css({'opacity':0.6});
  $('body').find('img').hover(
	function(){
		$(this).stop().animate({opacity:1},1000)
	},
	function(){
		$(this).stop().animate({opacity:0.6},1000)
	}
  )
});
</script>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

// The file that will be sent to the user

$your_file = 'file.zip';

// Rename the file name

$new_file = 'new-filename.zip';

// Set the download speed limit (70 kb/s)

$download_speed = 70;

if(file_exists($myl_file) && is_file($my_file)) {

    // Headers

    header('Cache-control: private');
    header('Content-Type: application/octet-stream');
    header('Content-Length: '.filesize($my_file));
    header('Content-Disposition: filename='.$new_file);

    // Flush the content

    flush();

    // File stream

    $file = fopen($my_file, "r");

    while (!feof($file)) {

        // Send the current part of the file to the browser

        echo fread($file, round($download_speed* 1024));

        // Flush the content to the browser

        flush();

        // Sleep one second

        sleep(1);
    }

    // Close file stream

    fclose($file);

}
else {
    die('Error: The file '.$my_file.' does not exist!');
}

1
2
3
4
5
6
7
8
9

<div id="container">
<div id="glass">
    <div id="water"></div>
</div>
</div>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

#container {
    background: rgba( 0, 0, 0, 0.10);
    margin-left:auto;
    margin-right:auto;
    width: 300px;
    border-left: 1px solid #bbb;
    border-right: 1px solid #bbb;
    border-bottom: 1px solid #bbb;
    border-top: 1px solid #ccc;
    -webkit-border-radius: 10px;
    -moz-border-radius: 10px;
    border-radius: 10px;
    padding-left: 5px;
    padding-right: 5px;
    padding-bottom: 30px;
    padding-top: 5px;
}
#glass {
    background: rgba( 255, 255, 255, 0.50);
    border: 1px solid #bbb;
    border-top: 1px solid #eee;
    -webkit-border-radius: 10px;
    -moz-border-radius: 10px;
    border-radius: 10px;
    width: 300px;
    height: 400px;
    position: relative;
}
#water {
    background-image: url("waves.png");
    background-position: top right;
    position: absolute;
    bottom: 0px;
    width: 300px;
    height: 100px;
    -webkit-transition: all 3s ease-out;
    -moz-transition: all 3s ease-out;
    -o-transition: all 3s ease-out;
    transition: all 3s ease-out;
    -webkit-border-radius: 10px;
    -moz-border-radius: 10px;
    border-radius: 10px;
}
#glass:hover #water {
    height: 350px;
    background-position: top left;
    -webkit-transition: all 3s ease-out;
    -moz-transition: all 3s ease-out;
    -o-transition: all 3s ease-out;
    transition: all 3s ease-out;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

-webkit-transition: all 200ms linear;
	-moz-transition: all 200ms linear;
	-o-transition: all 200ms linear;
	transition: all 200ms linear;
	-webkit-transform: translateZ(0);
	-moz-transform: translateZ(0);
	-o-transform: translateZ(0);
	transform: translateZ(0);

1
2
3
4
5
6
7

-webkit-transform: scale(1.1) translateZ(0);
	-moz-transform: scale(1.1) translateZ(0);
	-o-transform: scale(1.1) translateZ(0);
	transform: scale(1.1) translateZ(0);