xiaoma de blog » 软件[Code]

Tricks

admin — Sat, 18 Dec 2010 10:02:58 +0000

[Ubuntu]

ISSUE: Nvidia display driver problem on a two graphics card PC.

[EE] No devices detected. No screen found.

SOLUTION:

lspci -v

Get PCI bus number for graphics cards, 1:0:0 and 6:0:0 for instance.

sudo vi /etc/X11/xorg.conf

Under section “Device”, add

BusID “PCI:1:0:0″

Restart X and everything works like a charm.

http://wiki.linuxquestions.org/wiki/Using_multiple_monitors

[CUDA]

ISSUE: “error while loading shared libraries: libcudart.so.3: cannot open shared object file: No such file or directory”

SOLUTION:

sudo vim /etc/ld.so.conf

Add “/usr/local/cuda/lib”

Save and quit.

ld config -v | grep cuda

山寨的联通3G网卡，无型号，隆信通，在Ubuntu 11.10下使用：

lsusb信息如下：

Bus 003 Device 003: ID 05c6:6000 Qualcomm, Inc. Mass Storage Device.

使用如下命令切换到modem模式：

usb_modeswitch -v 05c6 -p 1000 -M 5553424312345678000000000000061b000000020000000000000000000000 -R 1
切换成功后可ls /dev/tty*看到ttyUSBx的设备。

打开网络配置用户名和密码都为any，pin码为1234，网络为3gnet，其余默认。

Compile PTAM&PTAMM on Snow Leopard

admin — Thu, 23 Sep 2010 14:15:49 +0000

1. Compile PTAM

1). Install TooN lib.

Download Toon.

-> cvs -z3 -d:pserver:anoncvs@cvs.savannah.nongnu.org:/cvsroot/toon co TooN

Make and install.

-> ./configure

-> make

-> make install

2). Install libcvd(32bit).

a) Download libcvd.

-> cvs -z3 -d:pserver:anoncvs@cvs.savannah.nongnu.org:/cvsroot/libcvd co libcvd

b) Edit cvd/gl_helpers.h. Use OpenGL/gl.h and OpenGL/glu.h.

c) Edit progs/calibrate.cxx. Replace GL_TEXTURE_RECTANGLE_NV with GL_TEXTURE_RECTANGLE_ARB.

d) Edit cvd_src/OSX/qtbuffer.cpp. Add #include

e) Create a new configure script configure_mac.sh:

#!/bin/bash

SDK="-isysroot /Developer/SDKs/MacOSX10.5.sdk"
SDKLIB="-Wl,-syslibroot,/Developer/SDKs/MacOSX10.5.sdk"
export MACOSX_DEPLOYMENT_TARGET="10.5"

ARCH="-arch i386"

export CFLAGS="$ARCH $SDK -mmacosx-version-min=10.5 -I /usr/local/include"
export CXXFLAGS="$ARCH $SDK -mmacosx-version-min=10.5 -I /usr/local/include"
export CPPFLAGS="$ARCH $SDK -mmacosx-version-min=10.5 -I /usr/local/include"
export LDFLAGS="$ARCH $SDKLIB -mmacosx-version-min=10.5 -I /usr/local/include"

CC="/usr/bin/gcc-4.2"
CXX="/usr/bin/g++-4.2"
OBJC="/usr/bin/gcc-4.2"

./configure $1 $2 $3 $4 $5 $6 $7 $8 $9

f) Configure.

-> ./configure_mac.sh --without-ffmpeg --x-libraries=/Developer/SDKs/MacOSX10.5.sdk/usr/X11/lib/ --x-includes=/Developer/SDKs/MacOSX10.5.sdk/usr/X11/include

g) Edit makefile.

Move all -L/opt/local/lib to the end of the argument list, giving priority to OSX10.5.sdk version of X11

h) Make and Install

-> make

-> install

3). Install gvars3

a) Download gvars3

-> cvs -z3 -d:pserver:anoncvs@cvs.savannah.nongnu.org:/cvsroot/libcvd co gvars3

b) Copy the previous configure_mac.sh.

-> sh configure_mac.sh --disable-widgets

-> make

-> make install

4). Compile PTAM

a) Copy /Build/OSX/Makefile and VideoSource_OSX.cc to source root directory.

b) Edit makefile. Compile 32bit.

-> CC = g++ -g -O3 -arch i386

-> make

-> make install

2. Compile PTAMM

a. Install lib3ds. Download the source. Copy configure_mac.sh. Do the same as above.

b. Copy PTAM/VideoSource_OSX.cc to PTAMM.

c. Copy PTAMM/Build/Linux/Makefile to PTAMM.

d. Edit VideoSource_OSX.cc. Add “namespace PTAMM{” after the includes and “}” at the end.

e. Edit makefile.

Change “LINKFLAGS = -L MY_CUSTOM_LINK_PATH -lGVars3 -lcvd $(3DSLIB)” => “LINKFLAGS = -framework OpenGL -framework VecLib -lGVars3 -lcvd $(3DSLIB)”.

Change “VIDEOSOURCE = VideoSource_Linux_DV.o” => “VIDEOSOURCE = VideoSource_OSX.o”

f. make and install.

Have fun:)

WPF path animation as opacity mask

admin — Thu, 03 Jun 2010 15:45:14 +0000

CODE

       xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
       xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
       x:Name=”Window”
       Title=”Path Opacity Mask Animation Demo”
       Width=”640″ Height=”480″ xmlns:System=”clr-namespace:System;assembly=mscorlib”>

Unity3D with Windows 7 Multitouch

admin — Fri, 12 Feb 2010 07:08:41 +0000

[There is a video that cannot be displayed in this feed. Visit the blog entry to see the video.]

Here it goes. Build Unity 3D multitouch application on Windows 7 machines.

This video demonstrates an application built with Unity 3D with Windowns 7 multitouch input.

Thanks to Unity explosion framework Detonator. Nice work!

Unity 3D First Try

admin — Wed, 10 Feb 2010 02:51:38 +0000

Please view the full post to see the Unity content.

This is part of a tutorial in the book “Unity Game Development Essentials”

Use mouse and keyboard to control walk through.

Up/W: Forward

Down/S: Backward

Left/A: Left

Right/D: Right

Mouse: Look around and turn the player

C# Passing Parameters

admin — Sun, 31 Jan 2010 12:01:42 +0000

C# Passing Parameters

Passing Value-Type Parameters

A value-type variable contains its data directly as opposed to a reference-type variable, which contains a reference to its data. Therefore, passing a value-type variable to a method means passing a copy of the variable to the method. Any changes to the parameter that take place inside the method have no affect on the original data stored in the variable. If you want the called method to change the value of the parameter, you have to pass it by reference, using the ref or out keyword.

The following example demonstrates passing value-type parameters by value. The variable n is passed by value to the method SquareIt. Any changes that take place inside the method have no affect on the original value of the variable.


class PassingValByVal
{
    static void SquareIt(int x)
    // The parameter x is passed by value.
    // Changes to x will not affect the original value of x.
    {
        x *= x;
        System.Console.WriteLine("The value inside the method: {0}", x);
    }
    static void Main()
    {
        int n = 5;
        System.Console.WriteLine("The value before calling the method: {0}", n);

        SquareIt(n);  // Passing the variable by value.
        System.Console.WriteLine("The value after calling the method: {0}", n);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
    The value before calling the method: 5
    The value inside the method: 25
    The value after calling the method: 5
*/

The variable n, being a value type, contains its data, the value 5. When SquareIt is invoked, the contents of n are copied into the parameter x, which is squared inside the method. In Main, however, the value of n is the same, before and after calling the SquareIt method. In fact, the change that takes place inside the method only affects the local variable x.

The following example is the same as the previous example, except for passing the parameter using the ref keyword. The value of the parameter is changed after calling the method.


class PassingValByRef
{
    static void SquareIt(ref int x)
    // The parameter x is passed by reference.
    // Changes to x will affect the original value of x.
    {
        x *= x;
        System.Console.WriteLine("The value inside the method: {0}", x);
    }
    static void Main()
    {
        int n = 5;
        System.Console.WriteLine("The value before calling the method: {0}", n);

        SquareIt(ref n);  // Passing the variable by reference.
        System.Console.WriteLine("The value after calling the method: {0}", n);

        // Keep the console window open in debug mode.
        System.Console.WriteLine("Press any key to exit.");
        System.Console.ReadKey();
    }
}
/* Output:
    The value before calling the method: 5
    The value inside the method: 25
    The value after calling the method: 25
*/

Passing Reference-Type Parameters

A variable of a reference type does not contain its data directly; it contains a reference to its data. When you pass a reference-type parameter by value, it is possible to change the data pointed to by the reference, such as the value of a class member. However, you cannot change the value of the reference itself; that is, you cannot use the same reference to allocate memory for a new class and have it persist outside the block. To do that, pass the parameter using the ref or out keyword.

The following example demonstrates passing a reference-type parameter, arr, by value, to a method, Change. Because the parameter is a reference to arr, it is possible to change the values of the array elements. However, the attempt to reassign the parameter to a different memory location only works inside the method and does not affect the original variable, arr.


class PassingRefByVal
{
    static void Change(int[] pArray)
    {
        pArray[0] = 888;  // This change affects the original element.
        pArray = new int[5] {-3, -1, -2, -3, -4};   // This change is local.
        System.Console.WriteLine("Inside the method, the first element is: {0}", pArray[0]);
    }

    static void Main()
    {
        int[] arr = {1, 4, 5};
        System.Console.WriteLine("Inside Main, before calling the method, the first element is: {0}", arr [0]);

        Change(arr);
        System.Console.WriteLine("Inside Main, after calling the method, the first element is: {0}", arr [0]);
    }
}
/* Output:
    Inside Main, before calling the method, the first element is: 1
    Inside the method, the first element is: -3
    Inside Main, after calling the method, the first element is: 888
*/

In the preceding example, the array, arr, which is a reference type, is passed to the method without the ref parameter. In such a case, a copy of the reference, which points to arr, is passed to the method. The output shows that it is possible for the method to change the contents of an array element, in this case from 1 to 888. However, allocating a new portion of memory by using the new operator inside the Change method makes the variable pArray reference a new array. Thus, any changes after that will not affect the original array, arr, which is created inside Main. In fact, two arrays are created in this example, one inside Main and one inside the Change method.

This example is the same as the previous example, except for using the ref keyword in the method header and call. Any changes that take place in the method will affect the original variables in the calling program.


class PassingRefByRef
{
    static void Change(ref int[] pArray)
    {
        // Both of the following changes will affect the original variables:
        pArray[0] = 888;
        pArray = new int[5] {-3, -1, -2, -3, -4};
        System.Console.WriteLine("Inside the method, the first element is: {0}", pArray[0]);
    }

    static void Main()
    {
        int[] arr = {1, 4, 5};
        System.Console.WriteLine("Inside Main, before calling the method, the first element is: {0}", arr[0]);

        Change(ref arr);
        System.Console.WriteLine("Inside Main, after calling the method, the first element is: {0}", arr[0]);
    }
}
/* Output:
    Inside Main, before calling the method, the first element is: 1
    Inside the method, the first element is: -3
    Inside Main, after calling the method, the first element is: -3
*/

All of the changes that take place inside the method affect the original array in Main. In fact, the original array is reallocated using the new operator. Thus, after calling the Change method, any reference to arr points to the five-element array, which is created in the Change method.

Swapping strings is a good example of passing reference-type parameters by reference. In the example, two strings, str1 and str2, are initialized in Main and passed to the SwapStrings method as parameters modified by the ref keyword. The two strings are swapped inside the method and inside Main as well.


class SwappingStrings
 {
     static void SwapStrings(ref string s1, ref string s2)
     // The string parameter is passed by reference.
     // Any changes on parameters will affect the original variables.
     {
         string temp = s1;
         s1 = s2;
         s2 = temp;
         System.Console.WriteLine("Inside the method: {0} {1}", s1, s2);
     }

     static void Main()
     {
         string str1 = "John";
         string str2 = "Smith";
         System.Console.WriteLine("Inside Main, before swapping: {0} {1}", str1, str2);

         SwapStrings(ref str1, ref str2);   // Passing strings by reference
         System.Console.WriteLine("Inside Main, after swapping: {0} {1}", str1, str2);
     }
 }
 /* Output:
     Inside Main, before swapping: John Smith
     Inside the method: Smith John
     Inside Main, after swapping: Smith John
*/

C# Boxing and Unboxing

admin — Sun, 31 Jan 2010 10:33:26 +0000

C# Boxing and Unboxing

Boxing is the process of converting a value type to the type object or to any interface type implemented by this value type. When the CLR boxes a value type, it wraps the value inside a System.Object and stores it on the managed heap. Unboxing extracts the value type from the object.

In relation to simple assignments, boxing and unboxing are computationally expensive processes. When a value type is boxed, a new object must be allocated and constructed. To a lesser degree, the cast required for unboxing is also expensive computationally.

Boxing

Boxing is used to store value types in the garbage-collected heap. Boxing is an implicit conversion of a value type to the type object or to any interface type implemented by this value type. Boxing a value type allocates an object instance on the heap and copies the value into the new object.

Consider the following declaration of a value-type variable:


int i=123;

The following statement implicitly applies the boxing operation on the variable i:


object o=i;      //Implicit boxing

The result of this statement is creating an object reference o, on the stack, that references a value of the type int, on the heap. This value is a copy of the value-type value assigned to the variable i. The difference between the two variables, i and o, is illustrated in the following figure.

Unboxing

Unboxing is an explicit conversion from the type object to a value type or from an interface type to a value type that implements the interface. An unboxing operation consists of:

Checking the object instance to make sure that it is a boxed value of the given value type.

Copying the value from the instance into the value-type variable.

The following statements demonstrate both boxing and unboxing operations:


int  i = 123;

object o = i;  //boxing

int j = (int) o;   //unboxing

The following figure demonstrates the result of the previous statements.

C# Common Type System

admin — Sun, 31 Jan 2010 08:26:29 +0000

C# Common Type System

The C# typing system contains the following categories:

Value types

Reference types

Pointer types

Variables that are value types store data, and those that are reference types store references to the actual data. Reference types are also referred to as objects. Pointer types can be used only in unsafe mode.

It is possible to convert a value type to a reference type, and back again to a value type, by using boxing and unboxing. With the exception of a boxed value type, you cannot convert a reference type to a value type.

Types can derive from other types, called base types. The derived type inherits (with some restrictions) the methods, properties, and other members of the base type. The base type can in turn derive from some other type, in which case the derived type inherits the members of both base types in its inheritance hierarchy. All types, including built-in numeric types such as System.Int32 (C# keyword: int), derive ultimately from a single base type, which is System.Object (C# keyword: object). This unified type hierarchy is called the Common Type System (CTS).

Each type in the CTS is defined as either a value type or a reference type. This includes all custom types in the .NET Framework class library and also your own user-defined types. Types that you define by using the struct keyword are value types; all the built-in numeric types are structs. Types that you define by using the class keyword are reference types. Reference types and value types have different compile-time rules, and different run-time behavior.

The following illustration shows the relationship between value types and reference types in the CTS.

Value Types

Value types derive from System.ValueType, which derives from System.Object. Types that derive from System.ValueType have special behavior in the CLR. Value type variables directly contain their values, which means that the memory is allocated inline in whatever context the variable is declared. There is no separate heap allocation or garbage collection overhead for value-type variables.

There are two categories of value types: struct and enum.

Value types are sealed, which means, for example, that you cannot derive a type from System..::.Int32, and you cannot define a struct to inherit from any user-defined class or struct because a struct can only inherit from System.ValueType. However, a struct can implement one or more interfaces. You can cast a struct type to an interface type; this causes a boxing operation to wrap the struct inside a reference type object on the managed heap. Boxing operations occur when you pass a value type to a method that takes a System.Object as an input parameter.

Reference Types

A type that is defined as a class, delegate, array, or interface is a reference type. At run time, when you declare a variable of a reference type, the variable contains the value null until you explicitly create an instance of the object by using the new operator, or assign it an object that has been created elsewhere by using new.

When the object is created, the memory is allocated on the managed heap, and the variable holds only a reference to the location of the object. Types on the managed heap require overhead both when they are allocated and when they are reclaimed by the automatic memory management functionality of the CLR, which is known as garbage collection. However, garbage collection is also highly optimized, and in most scenarios it does not create a performance issue.

iPhone开发真机运行（无iDP授权，省99美元）

admin — Fri, 02 Oct 2009 17:03:57 +0000

iPhone开发真机运行（无iDP授权，省99美元）

如果不需要考虑将软件放到AppStore上出售，自己开发自娱自乐，如下方式可省去iDP授权在真机上运行.

环境：Mac OS X Snow Leopard 10.6.1 + Xcode 3.1 + iPhone SDK 3.0

1. 安装Xcode与iPhone SDK；

2. 修改/Developer/Platforms/iPhoneOS.platform/info.plist, 在DefautProperties一栏下添加: PROVISIONING_PROFILE_ALLOWED = NO, PROVISIONING_PROFILE_REQUIRED = NO;

3. 修改/Developer/Platforms/iPhoneOS.platfomr/Developer/SDKs/iPhoneOS3.0sdk/SDKSettings.plist(可能需要到终端下用root权限), 修改CODE_SIGNING_REQUIRED = NO;

4. 在Xcode中，修改当前工程Device – 3.0 | Release下的plist，修改Build下Code Signing Identity = Don’t Code Sign;

5. 编译生成app文件，连接iPhone，打开Xcode中的Organizer，在Applications中选择添加编译生成的app文件。由于该app文件未经过签名，所以需要iPhone上事先安装能使用破解软件的工具，即在Cydia下添加source: http://cydia.hackulo.us，安装AppSync for OS3.0。下载成功即可运行自己开发的软件了。

补充：在Xcode 3.2中需要手动修改xx.xcodeproj文件。右键->Show Package Contents->用textmate打开project.pbxproj文件，修改所有的CODE_SIGN_IDENTITY为Don’t Code Sign，保存退出。

ARM linux开发点滴记录

admin — Sat, 26 Sep 2009 03:55:17 +0000

ARM linux开发点滴记录

1. USB转串口准备

下载Mac下USB转串口驱动, 推荐Z-tek, 性价比不错. 驱动下载www.z-tek.com.cn. 对大多数采用FTDI的USB转串口可以到www.ftdichip.com上下载驱动.安装驱动后重启.

cd /dev

ls -l

crw-rw-rw- 1 root wheel 2, 0 9 26 11:41 tty

crw-rw-rw- 1 root wheel 10, 2 9 26 11:41 tty.Bluetooth-Modem

crw-rw-rw- 1 root wheel 10, 4 9 26 11:41 tty.Bluetooth-PDA-Sync

crw-rw-rw- 1 root wheel 10, 0 9 26 11:41 tty.usbserial-ftCWUM24

crw-rw-rw- 1 root wheel 4, 0 9 26 11:41 ttyp0

crw-rw-rw- 1 root wheel 4, 1 9 26 11:41 ttyp1

crw-rw-rw- 1 root wheel 4, 2 9 26 11:41 ttyp2

crw-rw-rw- 1 root wheel 10, 0 9 26 11:41 tty.usbserial-ftCWUM24

2. Mac OS下安装minicom

Mac下安装minicom需要先安装darwinports.

先到darwinports.com下载并安装 darwingports.

然后开始安装minicom

cd /opt/loca/bin

sudo ./port install minicom

安装完毕之后运行minicom

./minicom

配置波特率,数据位等, 需要注意的是如果minicom只能读不能写,检查Hard flow control是设置为NO.

配置好之后连接开发板, minicom终端登录即可.

……

TCP cubic registered

RPC: Registered udp transport module.

RPC: Registered tcp transport module.

lib80211: common routines for IEEE802.11 drivers

s3c2410-rtc s3c2410-rtc: setting system clock to 2165-10-23 15:36:12 UTC (18842)

yaffs: dev is 32505858 name is “mtdblock2″

yaffs: passed flags “”

yaffs: Attempting MTD mount on 31.2, “mtdblock2″

yaffs_read_super: isCheckpointed 0

VFS: Mounted root (yaffs filesystem) on device 31:2.

Freeing init memory: 128K

hwclock: settimeofday() failed: Invalid argument

[16/Sep/2029:09:08:03 +0000] boa: server version Boa/0.94.13

[16/Sep/2029:09:08:03 +0000] boa: server built Mar 26 2009 at 15:28:42.

[16/Sep/2029:09:08:03 +0000] boa: starting server pid=501, port 80

Try to bring eth0 interface up……eth0: link down

Done

Please press Enter to activate this console.

[root@FriendlyARM /]#

3. Linux下安装Qt

编译范例出错，没有安装G++。

sudo apt-get install g++

再次build出错

p, li { white-space: pre-wrap; }

/usr/bin/ld: cannot find -lfreetype

安装QtCreator的dependencies

sudo apt-get install libfreetype6 libfreetype6-dev libglib2.0-dev libSM-dev libxrender-dev libfontconfig1-dev libxext-dev