当前位置：搜档网 › 各级图片浏览器带可以变成黑白图片功能

各级图片浏览器带可以变成黑白图片功能

初级图片浏览器（带可以变成黑白图片功能）,传说中的A*算法之简单实现,纯css(3)实现漂亮的照片墙效果,从s2p文件提取画S曲线的数据。

从驼峰命名的串中提取单词子串形成数组,单精度浮点数，双精度浮点数,当月的天数和一个月中第几天,导入2007EXCEL多字段时偷懒处理

public void update(Rect container) {

// update with collision

if (this.isAlive()) {

if (this.x <= container.left || this.x >= container.right - this.widht) {

this.xv *= -1;

}

// Bottom is 480 and top is 0 !!!

if (this.y <= container.top || this.y >= container.bottom - this.height) {

this.yv *= -1;

}

update();

}

//python模拟鼠标拖动操作

//python爬取百度云盘资源

public void draw(Canvas canvas) {

// paint.setARGB(255, 128, 255, 50);

paint.setColor(this.color);

canvas.drawRect(this.x, this.y, this.x + this.widht, this.y + this.height, paint);

// canvas.drawCircle(x, y, widht, paint);

}

//projecteuler73#题go与c++解题比较

//python中缀编程工具库pipe使用方法

[代码] ElaineAnimated.java

package net.obviam.walking.model;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.Rect;

public class ElaineAnimated {

private static final String TAG = ElaineAnimated.class.getSimpleName(); private Bitmap bitmap; // the animation sequence

private Rect sourceRect; // the rectangle to be drawn from the animation bitmap

private int frameNr; // number of frames in animation

private int currentFrame; // the current frame

private long frameTicker; // the time of the last frame update

private int framePeriod; // milliseconds between each frame (1000/fps)

private int spriteWidth; // the width of the sprite to calculate the cut out rectangle

private int spriteHeight; // the height of the sprite

private int x; // the X coordinate of the object (top left of the image)

private int y; // the Y coordinate of the object (top left of the image)

public ElaineAnimated(Bitmap bitmap, int x, int y, int width, int height, int fps, int frameCount) {

this.bitmap = bitmap;

this.x = x;

this.y = y;

currentFrame = 0;

frameNr = frameCount;

spriteWidth = bitmap.getWidth() / frameCount;

spriteHeight = bitmap.getHeight();

sourceRect = new Rect(0, 0, spriteWidth, spriteHeight);

framePeriod = 1000 / fps;

frameTicker = 0l;

}

public Bitmap getBitmap() {

return bitmap;

}

public void setBitmap(Bitmap bitmap) {

this.bitmap = bitmap;

}

public Rect getSourceRect() {

return sourceRect;

}

public void setSourceRect(Rect sourceRect) {

this.sourceRect = sourceRect;

}

public int getFrameNr() {

return frameNr;

}

public void setFrameNr(int frameNr) {

this.frameNr = frameNr;

}

public int getCurrentFrame() {

return currentFrame;

}

public void setCurrentFrame(int currentFrame) { this.currentFrame = currentFrame;

}

public int getFramePeriod() {

return framePeriod;

}

public void setFramePeriod(int framePeriod) { this.framePeriod = framePeriod;

}

public int getSpriteWidth() {

return spriteWidth;

}

public void setSpriteWidth(int spriteWidth) { this.spriteWidth = spriteWidth;

}

public int getSpriteHeight() {

return spriteHeight;

}

public void setSpriteHeight(int spriteHeight) { this.spriteHeight = spriteHeight;

}

public int getX() {

return x;

}

public void setX(int x) {

this.x = x;

}

public int getY() {

return y;

}

public void setY(int y) {

this.y = y;

}

// the update method for Elaine

public void update(long gameTime) {

if (gameTime > frameTicker + framePeriod) {

frameTicker = gameTime;

// increment the frame

currentFrame++;

if (currentFrame >= frameNr) {

currentFrame = 0;

}

// define the rectangle to cut out sprite

this.sourceRect.left = currentFrame * spriteWidth;

this.sourceRect.right = this.sourceRect.left + spriteWidth;

}

// the draw method which draws the corresponding frame

public void draw(Canvas canvas) {

// where to draw the sprite

Rect destRect = new Rect(getX(), getY(), getX() + spriteWidth, getY() + spriteHeight);

canvas.drawBitmap(bitmap, sourceRect, destRect, null);

canvas.drawBitmap(bitmap, 20, 150, null);

Paint paint = new Paint();

paint.setARGB(50, 0, 255, 0);

canvas.drawRect(20 + (currentFrame * destRect.width()), 150, 20 + (currentFrame * destRect.width()) + destRect.width(), 150 + destRect.height(), paint);

}

[文件] CLog-0.5.zip ~ 5KB 下载(140)

文件不存在或者代码语言不存在

[代码] [Java]代码

// desired fps

private final static int MAX_FPS = 50;

// maximum number of frames to be skipped

private final static int MAX_FRAME_SKIPS = 5;

// the frame period

private final static int FRAME_PERIOD = 1000 / MAX_FPS;

@Override

public void run() {

Canvas canvas;

Log.d(TAG, "Starting game loop");

long beginTime; // the time when the cycle begun

long timeDiff; // the time it took for the cycle to execute

int sleepTime; // ms to sleep (<0 if we're behind)

int framesSkipped; // number of frames being skipped

sleepTime = 0;

while (running) {

canvas = null;

// try locking the canvas for exclusive pixel editing

// in the surface

try {

canvas = this.surfaceHolder.lockCanvas();

synchronized (surfaceHolder) {

beginTime = System.currentTimeMillis();

framesSkipped = 0; // resetting the frames skipped

// update game state

this.gamePanel.update();

// render state to the screen

// draws the canvas on the panel

this.gamePanel.render(canvas);

// calculate how long did the cycle take

timeDiff = System.currentTimeMillis() - beginTime;

// calculate sleep time

sleepTime = (int)(FRAME_PERIOD - timeDiff);

if (sleepTime > 0) {

// if sleepTime > 0 we're OK

try {

// send the thread to sleep for a short period

// very useful for battery saving Thread.sleep(sleepTime);

} catch (InterruptedException e) {}

}

while (sleepTime <0&& framesSkipped <

MAX_FRAME_SKIPS) {

// we need to catch up

// update without rendering

this.gamePanel.update();

// add frame period to check if in next frame

sleepTime += FRAME_PERIOD;

framesSkipped++;

}

} finally {

// in case of an exception the surface is not left in // an inconsistent state

if (canvas != null) {

surfaceHolder.unlockCanvasAndPost(canvas);

}

} // end finally

}

[代码] DroidzActivity.java

package net.obviam.droidz;

import android.app.Activity;

import android.os.Bundle;

import android.util.Log;

import android.view.Window;

import android.view.WindowManager;

public class DroidzActivity extends Activity {

/** Called when the activity is first created. */

private static final String TAG = DroidzActivity.class.getSimpleName();

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

// requesting to turn the title OFF

requestWindowFeature(Window.FEATURE_NO_TITLE);

// making it full screen

getWindow().setFlags(https://www.sodocs.net/doc/5015967355.html,youtParams.FLAG_FULLSCREEN, https://www.sodocs.net/doc/5015967355.html,youtParams.FLAG_FULLSCREEN);

// set our MainGamePanel as the View

setContentView(new MainGamePanel(this));

Log.d(TAG, "View added");

}

@Override

protected void onDestroy() {

Log.d(TAG, "Destroying...");

super.onDestroy();

}

@Override

protected void onStop() {

Log.d(TAG, "Stopping...");

super.onStop();

}

.[代码] MainThread.java

package net.obviam.droidz;

import android.util.Log;

import android.view.SurfaceHolder;

public class MainThread extends Thread {

private static final String TAG = MainThread.class.getSimpleName();

private SurfaceHolder surfaceHolder;

private MainGamePanel gamePanel;

private boolean running;

public void setRunning(boolean running) {

this.running = running;

}

public MainThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) { super();

this.surfaceHolder = surfaceHolder;

this.gamePanel = gamePanel;

}

@Override

public void run() {

long tickCount = 0L;

Log.d(TAG, "Starting game loop");

while (running) {

tickCount++;

// update game state

// render state to the screen

}

Log.d(TAG, "Game loop executed " + tickCount + " times");

}

.[代码] MainGamePanel.java

package net.obviam.droidz;

import android.content.Context;

import android.graphics.Canvas;

import android.view.MotionEvent;

import android.view.SurfaceHolder;

import android.view.SurfaceView;

public class MainGamePanel extends SurfaceView implements

SurfaceHolder.Callback {

private MainThread thread;

public MainGamePanel(Context context) {

super(context);

getHolder().addCallback(this);

// create the game loop thread

thread = new MainThread();

setFocusable(true);

}

@Override

public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

}

@Override

public void surfaceCreated(SurfaceHolder holder) {

thread.setRunning(true);

thread.start();

}

@Override

public void surfaceDestroyed(SurfaceHolder holder) {

boolean retry = true;

while (retry) {

try {

thread.join();

retry = false;

} catch (InterruptedException e) {

// try again shutting down the thread

}

@Override

public boolean onTouchEvent(MotionEvent event) {

return super.onTouchEvent(event);

}

@Override

protected void onDraw(Canvas canvas) {

}

[代码] MainThread.java

package net.obviam.droidz;

import java.text.DecimalFormat;

import android.graphics.Canvas;

import android.util.Log;

import android.view.SurfaceHolder;

/**

* @author impaler

* The Main thread which contains the game loop. The thread must have access to * the surface view and holder to trigger events every game tick.

public class MainThread extends Thread {

private static final String TAG = MainThread.class.getSimpleName();

// desired fps

private final static int MAX_FPS = 50;

// maximum number of frames to be skipped

private final static int MAX_FRAME_SKIPS = 5;

// the frame period

private final static int FRAME_PERIOD = 1000 / MAX_FPS;

// Stuff for stats */

private DecimalFormat df = new DecimalFormat("0.##"); // 2 dp

// we'll be reading the stats every second

private final static int STAT_INTERVAL = 1000; //ms

// the average will be calculated by storing

// the last n FPSs

private final static int FPS_HISTORY_NR = 10;

// last time the status was stored

private long lastStatusStore = 0;

// the status time counter

private long statusIntervalTimer = 0l;

// number of frames skipped since the game started

private long totalFramesSkipped = 0l;

// number of frames skipped in a store cycle (1 sec)

private long framesSkippedPerStatCycle = 0l;

// number of rendered frames in an interval

private int frameCountPerStatCycle = 0;

private long totalFrameCount = 0l;

// the last FPS values

private double fpsStore[];

// the number of times the stat has been read

private long statsCount = 0;

// the average FPS since the game started

private double averageFps = 0.0;

// Surface holder that can access the physical surface

private SurfaceHolder surfaceHolder;

// The actual view that handles inputs

// and draws to the surface

private MainGamePanel gamePanel;

// flag to hold game state

private boolean running;

public void setRunning(boolean running) {

this.running = running;

}

public MainThread(SurfaceHolder surfaceHolder, MainGamePanel gamePanel) { super();

this.surfaceHolder = surfaceHolder;

this.gamePanel = gamePanel;

}

@Override

public void run() {

Canvas canvas;

Log.d(TAG, "Starting game loop");

// initialise timing elements for stat gathering

initTimingElements();

long beginTime; // the time when the cycle begun

long timeDiff; // the time it took for the cycle to execute int sleepTime; // ms to sleep (<0 if we're behind)

int framesSkipped; // number of frames being skipped

sleepTime = 0;

while (running) {

canvas = null;

// try locking the canvas for exclusive pixel editing // in the surface

try {

canvas = this.surfaceHolder.lockCanvas();

synchronized (surfaceHolder) {

beginTime = System.currentTimeMillis(); framesSkipped = 0; // resetting the frames skipped

// update game state

this.gamePanel.update();

// render state to the screen

// draws the canvas on the panel

this.gamePanel.render(canvas);

// calculate how long did the cycle take timeDiff = System.currentTimeMillis() - beginTime;

// calculate sleep time

sleepTime = (int)(FRAME_PERIOD - timeDiff);

if (sleepTime > 0) {

// if sleepTime > 0 we're OK

try {

// send the thread to

sleep for a short period

// very useful for battery saving

Thread.sleep(sleepTime);

} catch (InterruptedException e) {}

}

while (sleepTime <0&& framesSkipped < MAX_FRAME_SKIPS) {

// we need to catch up

this.gamePanel.update(); // update without rendering

sleepTime += FRAME_PERIOD; // add frame period to check if in next frame

framesSkipped++;

}

if (framesSkipped > 0) {

Log.d(TAG, "Skipped:" + framesSkipped);

}

// for statistics

framesSkippedPerStatCycle += framesSkipped;

// calling the routine to store the gathered statistics

storeStats();

}

} finally {

// in case of an exception the surface is not left in

// an inconsistent state

if (canvas != null) {

surfaceHolder.unlockCanvasAndPost(canvas);

}

} // end finally

}

/**

* The statistics - it is called every cycle, it checks if time since last

* store is greater than the statistics gathering period (1 sec) and if so * it calculates the FPS for the last period and stores it.

* It tracks the number of frames per period. The number of frames since * the start of the period are summed up and the calculation takes part * only if the next period and the frame count is reset to 0.

private void storeStats() {

frameCountPerStatCycle++;

totalFrameCount++;

// check the actual time

statusIntervalTimer += (System.currentTimeMillis() - statusIntervalTimer);

if (statusIntervalTimer >= lastStatusStore + STAT_INTERVAL) { // calculate the actual frames pers status check interval double actualFps = (double)(frameCountPerStatCycle / (STAT_INTERVAL / 1000));

//stores the latest fps in the array

fpsStore[(int) statsCount % FPS_HISTORY_NR] = actualFps;

// increase the number of times statistics was calculated statsCount++;

double totalFps = 0.0;

// sum up the stored fps values

for (int i = 0; i < FPS_HISTORY_NR; i++) {

totalFps += fpsStore[i];

}

// obtain the average

if (statsCount < FPS_HISTORY_NR) {

// in case of the first 10 triggers

averageFps = totalFps / statsCount;

} else {

averageFps = totalFps / FPS_HISTORY_NR;

}

// saving the number of total frames skipped

totalFramesSkipped += framesSkippedPerStatCycle;

// resetting the counters after a status record (1 sec) framesSkippedPerStatCycle = 0;

statusIntervalTimer = 0;

frameCountPerStatCycle = 0;

statusIntervalTimer = System.currentTimeMillis();

lastStatusStore = statusIntervalTimer;

// Log.d(TAG, "Average FPS:" + df.format(averageFps));

gamePanel.setAvgFps("FPS: " + df.format(averageFps)); }

}

private void initTimingElements() {

// initialise timing elements

fpsStore = new double[FPS_HISTORY_NR];

for (int i = 0; i < FPS_HISTORY_NR; i++) {

fpsStore[i] = 0.0;

}

Log.d(TAG + ".initTimingElements()", "Timing elements for stats initialised");

}

[代码] GlRenderer.java

https://www.sodocs.net/doc/5015967355.html, 小型臭氧发生器侳侱侲

package net.obviam.opengl;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLU;

import android.opengl.GLSurfaceView.Renderer;

public class GlRenderer implements Renderer {

private Triangle triangle; // the triangle to be drawn

/** Constructor to set the handed over context */

public GlRenderer() {

this.triangle = new Triangle();

}

@Override

public void onDrawFrame(GL10 gl) {

// clear Screen and Depth Buffer

gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

// Reset the Modelview Matrix

gl.glLoadIdentity();

// Drawing

gl.glTranslatef(0.0f, 0.0f, -5.0f); // move 5 units INTO the screen

// is the same as moving the camera 5 units away

// gl.glScalef(0.5f, 0.5f, 0.5f); // scale the triangle to 50%

// otherwise it will be too large

triangle.draw(gl); // Draw the triangle

}

@Override

public void onSurfaceChanged(GL10 gl, int width, int height) {

if(height == 0)

{ //Prevent A Divide By Zero By height = 1; //Making Height Equal One

}

gl.glViewport(0, 0, width, height); //Reset The Current Viewport

gl.glMatrixMode(GL10.GL_PROJECTION); //Select The Projection Matrix

gl.glLoadIdentity(); //Reset The Projection Matrix

//Calculate The Aspect Ratio Of The Window

GLU.gluPerspective(gl, 45.0f, (float)width / (float)height, 0.1f, 100.0f);

gl.glMatrixMode(GL10.GL_MODELVIEW); //Select The Modelview Matrix

gl.glLoadIdentity(); //Reset The Modelview Matrix

}

@Override

public void onSurfaceCreated(GL10 gl, EGLConfig config) {

}

.[代码] Triangle.java

package net.obviam.opengl;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import javax.microedition.khronos.opengles.GL10;

public class Triangle {

private FloatBuffer vertexBuffer; // buffer holding the vertices

private float vertices[] = {

-0.5f, -0.5f, 0.0f, // V1 - first vertex (x,y,z)

0.5f, -0.5f, 0.0f, // V2 - second vertex 0.0f, 0.5f, 0.0f // V3 - third vertex

};

public Triangle() {

// a float has 4 bytes so we allocate for each coordinate 4 bytes ByteBuffer vertexByteBuffer =

ByteBuffer.allocateDirect(vertices.length * 4);

vertexByteBuffer.order(ByteOrder.nativeOrder());

// allocates the memory from the byte buffer

vertexBuffer = vertexByteBuffer.asFloatBuffer();

// fill the vertexBuffer with the vertices

vertexBuffer.put(vertices);

// set the cursor position to the beginning of the buffer

vertexBuffer.position(0);

}

/** The draw method for the triangle with the GL context */

public void draw(GL10 gl) {

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

// set the colour for the background

// gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);

// to show the color (paint the screen) we need to clear the color buffer

// gl.glClear(GL10.GL_COLOR_BUFFER_BIT);

// set the colour for the triangle

gl.glColor4f(0.0f, 1.0f, 0.0f, 0.5f);

// Point to our vertex buffer

gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);

// Draw the vertices as triangle strip

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, vertices.length / 3);

//Disable the client state before leaving

gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);

}

.[代码] Run.java

package net.obviam.opengl;

import android.app.Activity;

import android.opengl.GLSurfaceView;

import android.os.Bundle;

import android.view.Window;

import android.view.WindowManager;

public class Run extends Activity {

/** The OpenGL view */

private GLSurfaceView glSurfaceView;

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

// requesting to turn the title OFF

requestWindowFeature(Window.FEATURE_NO_TITLE);

// making it full screen

getWindow().setFlags(https://www.sodocs.net/doc/5015967355.html,youtParams.FLAG_FULLSCREEN,

https://www.sodocs.net/doc/5015967355.html,youtParams.FLAG_FULLSCREEN);

// Initiate the Open GL view and

// create an instance with this activity

glSurfaceView = new GLSurfaceView(this);

// set our renderer to be the main renderer with

// the current activity context

glSurfaceView.setRenderer(new GlRenderer());

setContentView(glSurfaceView);

}

/**

* Remember to resume the glSurface

@Override

protected void onResume() {

super.onResume();

glSurfaceView.onResume();

}

/**

* Also pause the glSurface

*/https://www.sodocs.net/doc/5015967355.html,

@Override

protected void onPause() {

super.onPause();

glSurfaceView.onPause();

}

[代码] Run.java

package net.obviam.opengl;

import android.app.Activity;

import android.opengl.GLSurfaceView;

import android.os.Bundle;

import android.view.Window;

import android.view.WindowManager;

public class Run extends Activity {

/** The OpenGL view */

private GLSurfaceView glSurfaceView;

/** Called when the activity is first created. */

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

// requesting to turn the title OFF

requestWindowFeature(Window.FEATURE_NO_TITLE);

// making it full screen

getWindow().setFlags(https://www.sodocs.net/doc/5015967355.html,youtParams.FLAG_FULLSCREEN,

https://www.sodocs.net/doc/5015967355.html,youtParams.FLAG_FULLSCREEN);

// Initiate the Open GL view and

// create an instance with this activity

glSurfaceView = new GLSurfaceView(this);

// set our renderer to be the main renderer with

// the current activity context

glSurfaceView.setRenderer(new GlRenderer());

setContentView(glSurfaceView);

}

/** Remember to resume the glSurface */

@Override

protected void onResume() {

super.onResume();

glSurfaceView.onResume();

}

/** Also pause the glSurface */

@Override

protected void onPause() {

super.onPause();

glSurfaceView.onPause();

}

.[代码] GlRenderer.java

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLSurfaceView.Renderer;

public class GlRenderer implements Renderer {

@Override

public void onDrawFrame(GL10 gl) {

}

@Override

public void onSurfaceChanged(GL10 gl, int width, int height) { }

@Override

public void onSurfaceCreated(GL10 gl, EGLConfig config) {

}

[代码] GlRenderer.java

package net.obviam.opengl;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.opengl.GLU;

import android.opengl.GLSurfaceView.Renderer;

public class GlRenderer implements Renderer {

private Square square; // the square

private Context context;

/** Constructor to set the handed over context */

public GlRenderer(Context context) {

this.context = context;

黑白摄影中彩色滤镜的用途

黑白摄影中彩色滤镜的用途 (2012-10-23 16:11:48) 转载▼ 标签：黑白摄影彩色滤镜杂谈黑白摄影中彩色滤镜的用途： 1. 浅黄 (2E) 这种滤色片藉由强调黄色、橙色及红色的处理，使得作品显得更为温馨柔和与优雅。特别适用于妇女与小孩的人像摄影、自然光下对肤色色调改善、春天的风景照与大自然的摄影等。滤色片指数为1.5。 2. 中黄（8）利用这个滤色片可使绿色景物创造出更微妙的层次，亦可更细腻的描绘天空。我们尤其推荐将它应用在风景照及花草作物的摄影中。在日光下做人像摄影时，搭配此滤色片可将皮肤上的瑕疵及潮红淡化，使肤色较柔和，同时是浅色变质更讨好。滤色片指数为3。 3. 深黄翻拍沙滩及雪景等作品时，配用这个滤色片可以得到很显著的改善。它也可以加强花草作物的反差，使景物看起来更清晰。人工光源下做人像摄影时，使用这个滤色片能减轻皮肤上的瑕疵及雀斑。也能使眼球的颜色加深；使唇色变淡。滤色片指数为3。 4. 黄橙(16) 这片鲜橙色的滤色片可加深蓝、紫、绿以及黄绿等色调。对于偏好景物鲜明且轮廓清晰的风景照及建筑摄影来说，这个滤色片是绝对不可或缺的。蓝天在白云高反差的衬托下，更为凸显。这个滤色片亦广泛的被采用于日光下的人体摄影。滤色片指数为4。 5. 红橙（22）这个滤色片能使天空变暗，创造出风暴的戏剧化云彩效果，并利用高反差强化阴影暗部。在工商摄影时，也常用它来提升黄、橙及红色的亮度，以使色阶分明。滤色片指数为4。 6. 黄绿（11）此种滤色片能将各种不同色差的绿色景物区分出来，所以最适于用来拍摄风景照。尤其是拍摄春天的景色时，它藉由突显浅绿色调，来描绘嫩叶的景致。此外，由于它对红色色调具处理效果，因此也常被用在自然光下的人像摄影或团体照。滤色片指数为2。 7. 绿色（13）

javascript课程设计

潍坊科技学院 JavaScript课程设计报告书设计题目基于javascript的电子商务网站开发专业班级11软件一学生姓名江京翔学号201101080002 指导教师陈凤萍日期2012.12.24~2012.1.11 成绩

课程设计任务书院系：软件学院专业：软件技术班级：11软1 学号：201101080002 一、课程设计时间 2012年12月24日至2013年1月11日，共计3周。二、课程设计内容使用html+javascript+css 完成以下任务： 1、能够熟练使用css结合html实现网页布局。 2、熟练使用文档对象模型和事件驱动，能够很好的实现web表单的交互式操作。 3、熟练使用javascrip中的对象，实现网页的动态效果。三、课程设计要求 1. 课程设计质量： ?贯彻事件驱动的程序设计思想，熟练使用javascript中的对象，实现网页特效。 ?网页设计布局合理，色彩搭配合理，网页操作方便。 ?设计过程中充分考虑浏览器兼容等问题，并做适当处理。 ?代码应适当缩进，并给出必要的注释，以增强程序的可读性。 2. 课程设计说明书：课程结束后，上交课程设计报告书和相关的网页。课程设计报告书的格式和内容参见提供的模板。四、指导教师和学生签字指导教师：学生签名：江京翔五、教师评语：

基于javascript的电子商务网站开发摘要 JavaScript是开发WEB应用程序不可或缺的一种语言，无论是为web页面增加交互性还是创建整个应用程序，如果没有Javascript，今天的web就不是现在这个样子了。JavaScript是具有正式规范的基于标准语言；然而，正如任何一个web开发人员所告诉你的那样，几乎每个web浏览器对这个规范的解释都不同。本网站充分的结合了HTML与CSS的结合充分显示了网站的动态效果，是客户与网站能够充分的结合，进行信息的交换信息不断的进行更新。基于新闻管理网站，国外新闻页面更具有代表性，是网站最标准型之一，通过Javascript 脚本的交互式该页面更好与其他的页面相互结合。同时通常页面的下载是按照代码的排列顺序，而表格布局代码的排列代表从上向下，从左到右，无法改变。而通过CSS控制，您可以任意改变代码的排列顺序，比如将重要的右边内容先加载出来。关键字：节假日、日历、Javascript脚本

网页设计大作业

网页设计与制作报告书课程名称:网页设计与制作报告题目：几米的空间专业班级：旅管1002班学号：100104110221 姓名：杨玉颖指导教师：胡一波

目录一、................................. 开发背景二、................................. 网页设计技巧三、................................. 网站结构四、................................. 应用工具方案五、................................. 频道栏目划分六、................................. 测试七、................................. 周期与成本估算八、................................. 结论

摘要：在Internet飞速发展的今天，互联网成为人们快速获取、发布和传递信息的重要渠道，它在人们政治、经济、生活等各个方面发挥着重要的作用。因此网站建设在Internet应用上的地位显而易见，它已成为政府、企事业单位信息化建设中的重要组成部分，从而倍受人们的重视。关键字：网页制作；制作方法；设计要素；网页测试

一、网页制作开发背景 Dreamweaver以其功能强大、容易上手、界面亲切而著称。它采用所见即所得的方式编辑网页，利用它可以轻松的组织、编辑网页并将其发布到指定的站点上，而且在发布之后还能对更新情况进行监控以更新站点的内容。现在流行的网页制作软件有很多，如Macromedia 公司的Dreamweaver、微软公司的Dreamweaver、还有Adobe Pagemill 3.0--制作多框架，表单和Image map 图像的网页工具、Netscape等等。其中Dreamweaver更以其功能强大、容易上手、界面亲切而著称。它采用所见即所得的方式编辑网页，利用它可以轻松的组织、编辑网页并将其发布到指定的站点上，而且在发布之后还能对更新情况进行监控以更新站点的内容。工具准备好了，可根据你的个人喜好来选择一些素材，如图片、喜欢的文章等。二、网页制作设计技巧首先，我们来看一下创建一个只包含一个网页的站点。选择“文件”菜单的“新建”选项，单击“站点”命令，这时新建站点对话框就弹出来了，在“指定新站点位置”文本框中输入新站点的位置，单击“只有一个网页的站点”图标，单击“确定”按钮。这就建立好站点了，我们现在来看一下新的站点里有什么，单击“视图”工具条的“文件夹”按钮。在文件夹列表里有一个网页文件，名字叫做“index.htm”。我们知道，每

使用HTML5 转换彩色图片为黑白色

canvas