[함수] GD 를 이용한 통계용그래프 수정안2

출처 : http://www.phpschool.com/gnuboard4/bbs/board.php?bo_table=tipntech&wr_id=37178

오래전 만들어 올렷던 건데 좀 수정을 했습니다.
그라디에이션효과를 프로그램이 아닌 배경이미지를 이용해 나타냈고,
막대에 모양을 좀 이쁘게 했습니다.
링크에서 그라디에이션배경이미지 3개를 다른이름으로 저장해서 파일과
같은 경로에 넣어주세요. 그리고 ariali.ttf 폰트로 필요하니 윈도우에 있는 폰트파일
복사해다 같은 위치에 넣주세요.
----------------------------------------------------------------------
<?
class gdGraph{
function mainCall($data,$h,$margin="50",$weight="10",$copy="",$write){
//폰트가 있는 위치를 적어준다. /나 ./로 시작해 적어준다
$this->font = "./ariali.ttf";
//각각의 받은 값을 세팅
$this->data = $data;
$this->margin = $margin;
$this->copystr = $copy;
$this->weight = $weight;
if ($this->copystr) $this->copyright = 20;//카피라이트가 있다면 스여질공간 20확보
$this->h = $h;//이미지의 높이
$this->w = $this->margin * 2 + sizeof($this->data) * $this->weight;//이미지의 넓이

//각각의 역할을 하는 함수들 호출
$this->base();//이미지바탕을만든다
$this->gradation();//바탕의 그라디에이션효과
$this->nomograph();//가로세로선을 그린다
$this->selectmax();//맥스값을 구한다
$this->drawclumn();//막대를 그린다
if($write) $this->charwrite();//좌측에 쓰여지는 수치값
if($write) $this->numberwrite();//막대에 쓰여지는 수치값
if($write) $this->datewrite();//하단에 쓰여지는 수치값
$this->copywrite();//우측 카피라이트

//이미지출력
header('Content-type: image/png');
imagepng($this->image);
imagedestroy($this->image);
}
function base(){
$this->image = imagecreate($this->w + $this->copyright, $this->h);
$this->black = imagecolorallocate($this->image, 0, 0, 0);//검은색
$this->white = imagecolorallocate($this->image, 255, 255, 255);//흰색
$this->light_green = imagecolorallocate($this->image, 0, 183, 0);//가로줄, 세로줄의 색
$this->dark_green = imagecolorallocate($this->image, 153, 218, 148);//가로줄, 세로줄의 색
$this->bgcolor = imagecolorallocate($this->image, 215, 215, 215);//배경 회색
imagefill($this->image, 0, 0, $this->bgcolor);
}
function gradation(){
/*
배경에 그라디에이션을 넣는 부분인데 그라디에이션배경을 처리하면 막대의 그라디에이션이 깨진다.
아직 GD가 제대로 지원을 못하는 듯한데 같은 계열의 색을 배경으로 하면 깨지지 않는다.
하지만 초록색막대에 초록색 배경을 써야하니 이상하다.
아래 주석을 제거하면 볼 수 있다. 푸른색은 깨지고 녹색은 된다
*/
//$image = imagecreatefromgif("./rad01.gif");//푸른바탕은 이미지가 깨지다
//$image = imagecreatefromgif("./rad02.gif");//녹색바탕은 제대로 나온다
//imagecopyresized($this->image, $image, 0, 0, 0, 0, $this->w, $this->h, 200, 200);
}
function nomograph(){
//세로줄
imageline($this->image, $this->margin, $this->margin, $this->margin ,$this->h - $this->margin, $this->light_green);
imageline($this->image, $this->w - $this->margin, $this->margin, $this->w - $this->margin ,$this->h - $this->margin, $this->light_green);
//가로줄은 밝은녹색과 어두운녹색을 일정한 형식으로 반복해 그린다
if($this->h - $this->margin * 2 < 200) $tmp_cell=10;
else if ($this->h - $this->margin * 2 < 400) $tmp_cell=20;
else $tmp_cell=40;
$tmp_h=($this->h - $this->margin * 2) / $tmp_cell;
for ($i = 0 ; $i <= $tmp_cell ; $i++){
$tmp_he = $this->margin + $i * $tmp_h;
imageline($this->image, $this->margin - 3, $tmp_he, $this->w - $this->margin + 3, $tmp_he, ($i % ($tmp_cell / 10))?$this->dark_green:$this->light_green);
}
}
function selectmax(){
//그래프의 최대값을 구한다.
for ($i = 0 ; $i < sizeof($this->data) ; $i++){
if ($max < $this->data[$i]) $max = $this->data[$i];
}
$this->maxvalue=$max;
}
function drawclumn(){
for($i = 0 ; $i < sizeof($this->data) ; $i++){
//막대의 높이
$tmp_hvalue = ($this->h - $this->margin * 2) - $this->data[$i]/$this->maxvalue * ($this->h - $this->margin * 2) + $this->margin;
//막대의 그라디에이션
$image = imagecreatefromgif("./rad11.gif");
imagecopyresized($this->image, $image, $this->margin + $i * $this->weight + 1, $tmp_hvalue, 0, 0, $this->weight - 1, $this->h - $tmp_hvalue - $this->margin, 200, 200);
//막대의 외형모양을 꾸미는 라인들
imageline($this->image, $this->margin + $i * $this->weight + 1, $tmp_hvalue, $this->margin + $i * $this->weight + $this->weight, $tmp_hvalue, $this->white);
imageline($this->image, $this->margin + $i * $this->weight + 1, $tmp_hvalue, $this->margin + $i * $this->weight + 1, $this->h - $this->margin, $this->white);
imageline($this->image, $this->margin + $i * $this->weight + $this->weight, $tmp_hvalue, $this->margin + $i * $this->weight + $this->weight, $this->h - $this->margin, $this->black);
}
}
function charwrite(){
//우측글자쓰기
for ($i = 0 ; $i <= 10 ; $i++){
$value = round($this->maxvalue * (10 - $i) / 10,1);
$arr_size = imagettfbbox(7, 0, $this->font, $value);
$width = abs($arr_size[2] - $arr_size[0]);
$we = round($this->margin - $width - 10);
$height = abs($arr_size[5] - $arr_sixe[3]);
$he = round($height / 2);
$he = $this->margin + $i * (($this->h - $this->margin * 2) / 10) + $he;
imagettftext($this->image, 7 ,0, $we, $he, $this->black, $this->font, $value);
}
}
function numberwrite(){
//막대에 숫자쓰기
for($i = 0 ; $i < sizeof($this->data) ; $i++){
//글자의 높이
$tmp_hvalue = ($this->h - $this->margin * 2) - $this->data[$i]/$this->maxvalue * ($this->h - $this->margin * 2) + $this->margin;
//DATA수치쓰기
imagettftext($this->image, 7, 270, $this->margin + $i * $this->weight + 5,$tmp_hvalue + 2, $this->white, $this->font, $this->data[$i]);
}
}
function datewrite(){
//하단글자쓰기
for($i = 0 ; $i < sizeof($this->data) ; $i++){
if((($i + 1) % 5)==0 && $i){
$arr_size=imagettfbbox(7, 0, $this->font, $i + 1);
$width=abs($arr_size[2]-$arr_size[0]);
$we = ($this->weight - $width) / 2;
imagettftext($this->image, 7, 0, $this->margin + $i * $this->weight + $we, $this->h - $this->margin + 10, $this->black, $this->font, $i + 1);
}
}
}
function copywrite(){
if ($this->copystr){
//검은색으로 바탕을 만든다
imagefilledrectangle($this->image, $this->w, 0, $this->w + $this->copyright, $this->h, $this->black);
//글자의 키기를 구해 위치를 계산 중앙에 쓰여지게 한다
$arr_size=imagettfbbox(9, 270, $this->font, $this->copystr);
$height = abs($arr_size[5] - $arr_sixe[3]);
$he = round(($this->h - $height) / 2);
imagettftext($this->image, 9, 270, $this->w + 5, $he, $this->white, $this->font, $this->copystr);
}
}
}

//입력되는 데이터로 디비에서 불러와 처리해도 된다.
$arr_data=array(10,32,53,24,25,76,87,18,69,100,41,42,13,34,15,76,97,18,79,20,81,42,53,24,85,26,17,28,39,50,30);

//이미지의 높이
$height=500;

//이미지의 상하좌우여백
$margin=50;

//막대하나의 굵기
$weight=15;

//우측 카피라이트, 없으면 안나타남
$copy="Copyright CINUAE All rights reserved.";

//좌측과 하단, 막대의 숫자를 표시할 것인가를 결정(0,1)
$write=1;

//새로운 클래스를 만들어 호출
$mygdGraph=new gdGraph;
$mygdGraph->mainCall($arr_data,$height,$margin,$weight,$copy,$write);
?>

Writing Data CDs

출처 : http://www.vbaccelerator.com/home/net/code/Libraries/Writing_CDs/Writing_Data_CDs/article.asp

This article demonstrates how to use the IMAPI wrapper to burn data CDs (also known as "Joliet" format CDs). Sample code is provided in both C# and VB.

Writing Data CDs

Before you begin, note that this sample uses the IMAPI Wrapper for the CD burning functions. To run the sample, you will need to have acclImapiWrapper.DLL registered in the Global Assembly cache (GAC). If you place the DLL next to the executable in your Debug or Release directory then you will also be able to run (but you may need to change the project references to run in VS.NET).

Recording a data CD using IMAPI involves performing the following steps:

1. Initialise the library by obtaining a DiscMaster instance, setting the active mastering format to Joliet to obtain a JolietDiscMaster instance to build up the staging image that will be burnt to disc, and setting the active recorder.
2. Constructing a JolietDiscMasterStorage hierarchy to represent the files you want to burn to disc, and their filenames on disc.
3. Instructing JolietDiscMaster to copy the files from the JolietDiscMasterStorage to the disc image, and then burning the CD.

During the last step, the DiscMaster will raise a number of events describing progress as the disc is staged or burnt, and also allows the burn to be cancelled.

I'll describe these steps briefly with VB.NET code examples. The C# code is very similar; refer to the downloads for details.

1. Initialising the Library

The only directly instantiable class in the IMAPI Wrapper is the DiscMaster object, from which all other classes can be obtained. This can be declared WithEvents in VB because you'll want to catch the progress and cancel events. Next, the recording mode is set by obtaining a JolietDiscMaster object. A reference to the returned object is kept as this is needed to stage the image (calling the JolietDiscMaster() again will result in a new instance being returned). Having done that, the list of recorders is populated into a ComboBox and the selected index set.

    Private WithEvents discMaster As discMaster = Nothing    Private jolietDiscMaster As JolietDiscMaster = Nothing    Private Sub GetRecorders()        Dim ex As Exception        Try            discMaster = New DiscMaster()            jolietDiscMaster = discMaster.JolietDiscMaster()            Dim recorder As DiscRecorder            For Each recorder In discMaster.DiscRecorders                cboRecorder.Items.Add( _                 New ComboRecorderWrapper(recorder))            Next            If (cboRecorder.Items.Count > 0) Then                cboRecorder.SelectedIndex = 0            End If        Catch ex            MessageBox.Show( _                Me, String.Format("Unable to initialise the IMAPI library {0}", ex), _                Text, MessageBoxButtons.OK, MessageBoxIcon.Stop)            If Not (discMaster Is Nothing) Then                discMaster.Dispose()            End If        End Try    End Sub    Private Sub cboRecorder_SelectedIndexChanged( _            ByVal sender As Object, _            ByVal e As System.EventArgs _        ) Handles cboRecorder.SelectedIndexChanged        If (cboRecorder.SelectedIndex > -1) Then            Dim wrapper As ComboRecorderWrapper = cboRecorder.SelectedItem            discMaster.DiscRecorders.ActiveDiscRecorder = wrapper.DiscRecorder        End If    End Sub

As noted in the IMAPI Wrapper article, you must ensure that the Dispose method is called on the DiscMaster instance before ending your application. Failure to do this will result in any subsequent attempt to access the library failing with a "Stash In Use" error. To ensure this occurs, I've included an Application ThreadException handler, which is called in the unfortunate event of an untrapped exception in the code:

    Public Sub New()	' ...         'Add any initialization after the InitializeComponent() call        AddHandler Application.ThreadException,             AddressOf application_ThreadException              Show()        Refresh()        GetRecorders()    End Sub    Private Sub application_ThreadException( _        ByVal sender As Object, _        ByVal e As ThreadExceptionEventArgs)        MessageBox.Show(Me, _           String.Format("An untrapped exception occurred: {0}.", _             e.Exception), _             Text, MessageBoxButtons.OK, MessageBoxIcon.Error)        Close()    End Sub    Protected Overrides Sub OnClosing( _        ByVal e As System.ComponentModel.CancelEventArgs)        ' ....        '// Clear up:        MyBase.OnClosing(e)        Cursor.Current = Cursors.WaitCursor        sbrMain.Text = "Closing IMAPI interface..."        jolietDiscMaster.Dispose()        discMaster.Dispose()        Cursor.Current = Cursors.Default    End Sub

In this sample I'm exposing the stack trace of the exception directly; in a real application this would be bad practice and really the exception should be logged and a more descriptive message shown.

2. Constructing a JolietDiscMasterStorage hierarchy

The JolietDiscMaster instance exposes a RootStorage property, which returns a JolietDiscMasterStorage instance representing the root directory of the CD. You can add files and/or sub-directories to this object; sub-directories are also represented as JolietDiscMasterStorage objects. When adding a file, you specify the path of the file to copy from on disc and the name of the file in the directory to write it out to. Sub-directories just have a name. For the purposes of the sample, I just allow a directory to be added and optionally recursed:

    ''' <summary>    ''' Adds a directory to the storage, optionally including    ''' any subdirectories.    ''' </summary>    ''' <param name="path">Path to the directory to add</param>    ''' <param name="recurse"><c>true</c> to include subdirectories,    ''' <c>false</c> otherwise.</param>    Public Sub AddDirectory(ByVal path As String, ByVal recurse As Boolean)        Dim storage As JolietDiscMasterStorage = jolietDiscMaster.RootStorage        AddFilesToStorage(storage, path, recurse)    End Sub    Private Sub AddFilesToStorage( _        ByVal storage As JolietDiscMasterStorage, _        ByVal startPath As String, _        ByVal recurse As Boolean)        If (recurse) Then            Dim dir As String            For Each dir In Directory.GetDirectories(startPath)                Dim subStorage As JolietDiscMasterStorage = _                    storage.CreateSubFolder(Path.GetFileName(dir))                AddFilesToStorage(subStorage, dir, recurse)                        Next        End If        Dim file As String        For Each file In Directory.GetFiles(startPath)            storage.AddFile(file, Path.GetFileName(file))        Next    End Sub

Burning the Disc

With that done, creating the disc is easy: firstly any existing content in the image is cleared, then data is added using the AddData method of JolietDiscMaster and finally the disc is recorded using the DiscMasterRecordDisc method:

    ''' <summary>    ''' Creates a data CD from the specified files    ''' </summary>    ''' <param name="simulate">Simulate CD burning</param>    ''' <param name="ejectWhenComplete"><c>true</c> to eject the CD    ''' tray when the burn is complete, <c>false</c> otherwise</param>    ''' <param name="overwrite"><c>true</c> to overwrite existing files    ''' on CDRW media, <c>false</c> otherwise</param>    Public Sub CreateCD( _              ByVal simulate As Boolean, _              ByVal ejectWhenComplete As Boolean, _              ByVal overwrite As Boolean        )        '// Ensure we don't have anything in the stage        discMaster.ClearFormatContent()        '// Stage the content        jolietDiscMaster.AddData(overwrite)        '// burn the disc        discMaster.RecordDisc(simulate, ejectWhenComplete)        '// Easy!    End Sub

Whilst burning is in progress, there are six events to respond to:

1. AddProgress - raised as files are added to the image.
2. PreparingBurn - raised once the image has been created and the CD is about to burnt.
3. BlockProgress - raised as blocks are burnt to disc (a block is 2048 bytes).
4. ClosingDisc - raised once the burn has completed and the CD (or session) is about to be closed.
5. Complete - raised when the burn has completed.
6. QueryCancel - raised whilst data is added to the image or burning is in progress. Setting the Cancel property of the event arguments will cancel the operation.

That is really all you need to do to create the disc; however, if you want to be able to respond to cancellations, or to show progress you will need to write your application so the burn runs on a background thread. The construction of the wrapper makes this very easy to do using BeginInvoke.

Using BeginInvoke for a Smooth User Experience

Buring a CD is typically a long operation. If you invoke a burn operation on the user-interface thread, then the application will appear to be locked up whilst the burn occurs. Under XP and above, a feature was added which allows the caption and border of the window to be unfrozen if XP detects that the application has been locked up for a significant length of time. After this point in .NET Framework applications, calls to update controls and so forth no longer have any effect.

Therefore we want a way to invoke the CD burn on a background thread. Since the IMAPI wrapper makes a call to check whether the burn is cancelled at frequent intervals, and this is done through an event, there is also a safe way to cancel a burn operation at any time.

Any method in a class can be invoked asynchronously in .NET by creating a delegate for it. Once you have done this, the compiler is responsible for automatically creating three methods for the delegate:

1. The Invoke method, which has the same parameters and return value as the delegate and allows the method to be called synchronously.
2. The BeginInvoke method, which is the same as Invoke except it adds two more parameters: an AsyncCallback delegate and an object to hold state.
3. The EndInvoke method, which the same return value as the delegate, any ref or out parameters and an extra parameter holding an IAsyncResult object.

This makes asynchronous invocation easy. There are four coding steps:

1. Declare a delegate for the method you want to call asynchronously.
2. Write a completion event handler for the method you want to call, which will be called when the method completes.
3. Create an AsyncCallback handler and connect it to your completion event handler.
4. Invoke the delegate's method asynchronously using BeginInvoke.

Here's the code for doing this in VB and C#. Unsurprisingly the code is very similar; the only real difference being VB's odd use of AddressOf to refer to delegates. In this case the method I want to call is the CreateCD method implemented in my DataCDCreator class. This method takes three boolean parameters (for simulate burn, eject when complete and overwrite) and has no return value:

VB Code for Asynchronous Invocation

''' <summary>''' Delegate representing the CreateCD method''' </summary>Public Delegate Sub CreateCDDelegate( _    ByVal simulate As Boolean, _    ByVal ejectWhenComplete As Boolean, _    ByVal overwrite As Boolean)

    Private creator As DataCDCreator = Nothing    Private createCDHandler As CreateCDDelegate = Nothing        ' Asynchronously invoke the creator        creator = New DataCDCreator(discMaster, jolietDiscMaster)        creator.AddDirectory(txtFolder.Text, True)        createCDHandler = AddressOf creator.CreateCD        Dim callback As AsyncCallback = AddressOf createCD_Complete        Dim ar As IAsyncResult = createCDHandler.BeginInvoke( _            simulate, ejectWhenComplete, overwrite, callback, Nothing)    ''' <summary>    ''' Called when CD creation completes    ''' </summary>    ''' <param name="ar">Result of method call (none)</param>    Private Sub createCD_Complete(ByVal ar As IAsyncResult)        ' NB should surround with try - catch - end try        SetApplicationMode(False)        createCDHandler.EndInvoke(ar)    End Sub

C# Code for Asynchronous Invocation

   /// <summary>   /// Delegate representing the CreateCD method   /// </summary>   public delegate void CreateCDDelegate(       bool simulate,        bool ejectWhenComplete,        bool overwrite);

      private DataCDCreator creator = null;      private CreateCDDelegate createCDHandler = null;        // Asynchronously invoke the creator        creator = new DataCDCreator(discMaster, jolietDiscMaster);        creator.AddDirectory(txtFolder.Text, true);                       createCDHandler = new CreateCDDelegate(creator.CreateCD);        AsyncCallback callback = new AsyncCallback(createCD_Complete);        IAsyncResult ar = createCDHandler.BeginInvoke(            simulate, ejectWhenComplete, overwrite, callback, null);      /// <summary>      /// Called when CD creation completes      /// </summary>      /// <param name="ar">Result of method call (none)</param>      private void createCD_Complete(IAsyncResult ar)      {         // NB should surround with try-catch         SetApplicationMode(false);         createCDHandler.EndInvoke(ar);      }

More Ideas

The sample application here is rather trivial, in that all it allows you to do is to copy an existing directory to the CD. However, that's not an actual limitation, since when you create the storage you can specify that any file is mapped to a different path and or file on the destination CD. A more complete application would allow you to drag files from any location to the CD, and rename them if possible.

You could use this code to create an almost unattended CD writer (the only thing you need to do is to ensure suitable media is available in the drive) rather than having a UI.

Conclusion

This article demonstrates how to create Data CDs from VB or C# using the IMAPI Wrapper. Although the sample has a simple UI it performs all of the major operations you'll need to perform and should be easy to extend.

Graphs on Flash - usingActionScript!

Posted on July 9, 2006. Filed under: ActionScript, Graphics |

I have been reading up on ActionScript for a few days now. I started from the very basics, and decided that I would not directly dive into it without having any prior knowledge. Made a bit of progress. I wrote my first ActionScript program today. And it worked beautifully. This gives me a lot of ideas for future programs. Hopefully learning this will aid me in learning Javascript, as I think they are similar in many aspects.

I chose a 640×480 resolution for the movie. It’s a pretty simple program, and the one that I always try if I have the power of graphics. So far I have been able to work on graphics only in Turbo C++ with the graphics.h header file that comes along with it. But then ever since I shifted to standard C++, I have not had the opportunity to use graphics in any of my programs. This program is to draw the graph of any function. In this very basic code, the function has to be changed in the source code. Here’s my code:

var s:Number=48;
var i:Number=0;
var j:Number=0;
this.createEmptyMovieClip(”graph”, 1);
graph.lineStyle(1,0×000000,100);//(pixel width,colour,alpha)
do{
j=240-s*Math.sin((i-240)/s);
graph.moveTo(i,j);
i++;
j=240-s*Math.sin((i-240)/s);
graph.lineTo(i,j);
}while(i<640);

It basically draws the sine curve on screen. The createEmptyMovieClip command is required to create an object that will call the functions that are part the object of type MovieClip, like the ones that involves graphics. I don’t know what exactly the second parameter is supposed to do. It’s called “depth” and a value of 1 worked fine for me. I haven’t understood it’s exact purpose yet.

Here’s the output that I got for the above program:

The lines are a little jagged due to resizing.

That made me real happy. At first, I didn’t get any output. But later I realised I need to call the lineStyle function to change the plot colour to black and to draw properly.

I decided to plot other functions as well, and the next one that came to my mind was the normal distribution curve. Here, I changed only one of the expressions in the code to the new formula - instead of both - by mistake. But the output was amusing:

The region between the sine curve and the normal distribution curve is shaded. This is of course because the moveTo command moves the current position indicator to a point on one curve, and the lineTo draws a line from here to a point on the other curve. This gives a nice effect to the graph.
There was no stopping me now and I just kept trying out more functions one after the other. Here’s f(x)=exp(-x/3)*sin(3x) :

Since I found this simple enough, I decided to plot Mandelbrot’s set and was wondering if ActionScript could take that fairly higher amount of intensive calculations. But I was feeling really sleepy at around this time, and I don’t know if the program did not work because I was too sleepy to debug it properly or if Flash couldn’t handle it. I think it is the former . I suppose I’ll tackle that some other day.

var s:Number=48;
var i:Number=0;
var j:Number=0;
this.createEmptyMovieClip("graph", 1);
graph.lineStyle(1,0x000000,100);//(pixel width,colour,alpha)
do{
j=240-s*Math.sin((i-240)/s)*Math.tan((i-240)/s);
graph.moveTo(i,j);
i++;
j=240-s*Math.sin((i-240)/s)*Math.tan((i-240)/s);
graph.lineTo(i,j);
}while(i<640);

The source file include class files, so this is a Flash MX 2004 movie. Otherwise, it can be done by Flash MX.

Evaluate the equation object

I have discussed in previous session how to parse a string and get the value of an equation. At the end, I also discussed how to handle an equation string with variables. So, it is not difficult to get the value of "sin(x)" when we set x=0.3;

When we draw equation graph, we need to sample many x values and get the result of the equation before we plot those data out. We can accomplish this by repeated setting x and parsing the equation to get a new result.

However, to parse an equation string, we need to screen each character for existance of parenthesis and existance of any operator in the operatorSet array. It is time consuming.

Since what gets changed is the variable value only, the existence and position of the operators and parenthesis are the same as before , repeated parsing is not necessary. We can store down the operators and parenthesis. That is what my EquationObject class serves.

By this algorithm, to handle 100 sample x and get 100 y value is not a hard job any more. My evaluator does not evaluate the equation string. It evaluate the instance of EquationObject.

In this movie, about 400 x values are sampled. This is faster and more efficient.

The fit of Y range

Here is the scenario. We set x and y range from 0 to 8. We plot the equation "sin(x)". Well, half of the y points fall into the negative region. That means half of the curve is out of the lower bound of the canvas. Besides, the curve is located low and occupies only one-eighth of the canvas leaving a large blank area in the upper half. This is ugly and stupid.

To correct this, we need to calculate the Y range of the curve. We walk through each y value in the y Array and pick the maximal value and minimal value. Calculate the y range by yMax-yMin so that we can plot and fit our curve to the canvas.The highest point of the curve should fall on the top edge of the canvas and the lowest point of the curve should fall on the bottom edge of the canvas.

Unfortunately, the policy is not always possible. There are bugs. Lets try to remove the bug.

P.S. in my source file, if we set yMin, yMax then the automatic fit function is disabled. This is necessary in some condition, such as doing a comparison between two equations.

The infinity - range too big

Check this scenario. How to plot the equation "1/x" with x ranging from -1 to 1 ?

When x=0, the value is infinity. Even worse, when x is near the x, the value 1/x is very very large. If we accept that y value, then the y range is very large. The curve is very ugly.

Can you guess what it had looked like ? Well, the graph shows a max point at the upper edge and all other points fall at the lower edge of the canvas. Yes, since the y range is very large, all values are zoomed out as if those values are nearly 0 except the max point.

To correct this, I have to skip off those infinity values or values that are un-acceptably large compared with other values. The algorithm should not be too complex. Flash can easily hang out for complex algorithm.

I write a simple script. I calculate the slope of the curve. When the curve is curving upward or downward too sharply, I take that point as infinity and skip it off. Mathematically, this algorithm may not be so reasonable, but it does serve our goal.

So, if we plot the equation "1/x" from -1 to 1, we see the points near the x=0 zone are missing.　

The flat line - range too small

Scenario: How to plot the equation "sin(x)^2+cos(x)^2" with whatever x range ?

Well, for any x value, the result theoretically is always 1. So we expect to see a flat line on our canvas. No ?

My script would try to put the maximum value at the upper edge and minimum value at the lower edge of the canvas. If the "curve" is a flat horizontal line, how could it possibly do this ?

Can you guess how this equation had been plot ? Well, the result is a bizzare up and down spike.

Flash has limitation in calculation of float point. Besides, the sin and cos functions are just giving estimated values. In fact, when Flash calculate sin(x)^2+cos(x)^2, it gives a value "almost" 1 but not just 1. So, the result of the plot is still a curve with minute up and down not just a flat line. Since the difference between y max and y min is minute, the range is minute and the zoom-in effect is large. The end result is magnification of the up and down of the curve.

To correct this, we add some script to rule out such condition. When y range is too small, we add 5 as its maximum value and subtract 5 as its minimum value.

make the grid scales

Scenario: If I my bottom value is 10.1 and top value is 90, I want to draw grid lines at position where it represent 20- 40- 60- 80 - that counts 4 grid lines. If the top value is 55, I would draw grid lines at 20-30-40-50- total 4 lines. If the top value is 30, then I draw lines at 15 - 20 - 25 -30 total 4 lines.

Principle 1 : I want to keep the number of grid lines around 4 lines, 3 or 5 are acceptable.

Principle 2 : I want the grid line position "rounded" to 0 or 5 if possible. Positions such as 53- 76 -99 -122 should be avoid. In stead, I would hope it to be 50 - 75 -100 -125, although it may be one line more or less.

Well, it is more difficult than I had expected. So, I can not but use a brutal way.

First, I estimate what is the power of 10 for the space. Is it 0.01, or 0.1, or 1 or 10, or 100, or 1000 ? This is done through the log10. The script is like this : Math.floor(Math.log(dx)/Math.LN10);

For a result such as 10, then I test 2, 5, 10, 20, 50 and see how many lines I need to draw, if it counts less than 5, accept it.

If anyone knows a better way, please email me. I would appreciate sincerely.

Sampling limitation

Here is scenario: Plot a graph on to a canvas of 300-pixel-wide for equation "y=sin(x)", with x=-300 to 300.

The result is very ugly and useless because we plot it with in-adequate x sampling. Not every "peak" of the sin wave gets caught. So, not only the straight lines replace the curves, the repeated peaks in the graph do not sit at the same height as we expected.

Lets go back to that scenario. How about plot is with x range 0 to 8. The result is a beautiful curve. Is this beautiful sin wave plot accurate enough ? Here we see two peaks. Are they at the same height ? No. Not exactly.

The peak should occurr when x=(Math.PI)/2 , around half of 3.14159..... I dont think we pick that point exactly.

Theoretically, the peak when x=PI/2 should be at height of 1. No, in our graph, no single Y value is exactly 1.

How many sampling is "enough" ? I dont think there is an easy answer.　

The equation grapher

download source fla

ericlin@ms1.hinet.net

http://ericlin2.tripod.com/math2/graphQuizt.html

http://support.microsoft.com/kb/892462

To Read This,

Microsoft Knowledge Base Article

Article ID: 892462 - Last Review: May 31, 2007 - Revision: 1.5

How to use Visual C# to obtain the color of the pixel that is referenced by the mouse pointer

View products that this article applies to.

Expand all | Collapse all

INTRODUCTION

This article describes how to use Microsoft Visual C# to obtain the color of the pixel that is referenced by the mouse pointer.

Back to the top

MORE INFORMATION

To obtain the color of the pixel that is referenced by the mouse pointer by using Visual C#, follow these steps:

1. In Microsoft Visual Studio .NET 2003, create a new Visual C# Windows application.
2. Add a Label control that is named label1 to capture the pixel color.
3. Create a class that contains the Dlllmport statements that are required to call the Microsoft Windows GDI functions, and then capture an image that represents the current desktop.
4. Associate the MouseDown event of the label with an event handler that is named label1_MouseDown.
5. In the label1_MouseDown event handler, capture an image of the current desktop.
6. Associate the MouseUp event of the label with an event handler that is named label1_MouseUp.
7. In the label1_MouseUp event handler, retrieve the color that is associated with the current pixel location of the mouse pointer, and then set the BackColor of label1 to the color of the mouse pointer pixel.

The following steps are detailed steps to obtain the color of the pixel that is referenced by the mouse pointer:

1. In Visual Studio .NET 2003, create a new Visual C# Windows application.
2. Add one Windows Forms Label control to Form1.cs.
3. Click the label1 control, and then change the Text property to an empty string.
4. Change the BorderStyle property to FixedSingle.
5. In the Solution Explorer, right-click Form1.cs, and then click View Code.
6. Add the following Using statements to the top of the Form1.cs source code.

   using System.Runtime.InteropServices;

   Note This step adds the required references to call the InteropServices functions and methods.
7. Add the following Bitmap variable to Form1.cs at the start of the Form1 class.

   private Bitmap myBitmap;

8. Add the following Win32APICall class to Form1.cs after the Form1 class.