subset « WordPress.com Tag Feed

Recorte Irregular no ERDAS 9.1

sadeckgeo — Fri, 02 May 2008 15:37:42 +0000

Depois de termos apresentado um tutorial sobre recorte regular no ERDAS 9.1, muitas perguntas chegaram sobre recorte irregular ou com limites de municípios ou áreas especiais. Apesar de já termos feito alguns tutoriais de outros softwares com essa temática, alguns técnicos só dispõem de licenças para outros softwares, por isso, vamos agora ao recorte irregular no ERDAS 9.1.

Bom trabalho!!!!!

Até a próxima.

Por: Luis Sadeck

Recorte Regular - ERDAS 9.1

sadeckgeo — Sun, 27 Apr 2008 20:32:20 +0000

Olá a todos, hoje vamos demonstrar como se faz o processo de recorte regular no Software ERDAS 9.1. Esse processo é bastante usado quando nossa área de trabalho não abrange a(s) imagem(s) toda(s) e precisamos retirar uma parte da informação que, nesse caso é desnecessária.

Optamos hoje pelo recorte regular, pensando na criação do Layout da carta imagem depois, ou seja, com o recorte regular você terá uma apresentação visual bem melhor.

Então vamos ao que importa.

Um abraço a todos e até a próxima.

Por: Luis Sadeck

Fibromyalgia and CIDP

linzworld — Fri, 08 Feb 2008 08:15:48 +0000

A study published in the February edition of the Oxford journal Rheumatology has found that a significant subset of Fibromyalgia patients show findings suggestive of chronic inflammatory demyelinating polyneuropathy (CIDP).

The researchers said in their article that the "aetiopathogenesis [cause(s) and mechanisms] of... fibromyalgia ...(FMS) remains unknown", but recent reports "suggest that a subgroup of FMS subjects has an immune-mediated disease". The researchers primary objective was to study FMS subjects for evidence of an immune-mediated demyelinating polyneuropathy and their secondary objective was to determine the effects of treating these FMS subjects with the immune modulator, intravenous immunoglobulin (IVIg), which is used to treat CIDP. I'm not sure which "recent reports" they are referring to, but I wonder whether part of that was the South Korean study, published last year, that found some FMS patients have demyelinated nerve cells in the skin.

Fifty-eight FMS subjects, 26 rheumatic non-FMS subjects and 52 non-rheumatic non-FMS subjects were studied. Subjective measures of paraesthesias (numbness/pins-and-needles), weakness, stocking hypaesthesia (decrease in sensitivity of the feet), pain, fatigue and stiffness were made. Objective measures of tenderness, proximal muscle strength and electrodiagnostic (EDX) evidence of polyneuropathy and demyelination were also made. Eleven other FMS subjects underwent sural nerve biopsy.

The researchers found that paraesthesias, subjective weakness and stocking hypaesthesia were more common in FMS than in rheumatic patients without FMS. Proximal muscle strength was less in FMS than in rheumatic patients without FMS. EDX demonstrated a distal demyelinating polyneuropathy, suggestive of chronic inflammatory demyelinating polyneuropathy (CIDP), in 33% of FMS subjects. No rheumatic patients without FMS had polyneuropathy, or demyelination. Fifteen FMS/CIDP subjects were subsequently treated with IVIg and pain, tenderness and strength improved significantly. Fatigue and stiffness trended towards improvement.

The researchers concluded that

"A significant subset of FMS subjects have clinical and EDX findings suggestive of CIDP. IVIg treatment shows promise in treating this subset. These observations have implications for better understanding and treating some FMS patients."

Jave Code : generate all possible subsets

krackjack365 — Wed, 06 Feb 2008 06:58:27 +0000

import java.util.*;

/**
 * Illustrate subset generation via recursion
 * and by counting in binary and masking/shifting.
 * Neither method is demonstrably superior to the others.
 * <P>
 * Also shows abstract classes, use of inheritance to
 * process subsets, and timing in Java
 * <P>
 * @author Owen Astrachan
 *
 */

public class SubsetStuff
{
    /**
     * Class to process one subset. In general, subset generators
     * will call startAll, generate all subsets, then call finishAll.
     * The doOne method will be called for each element in some
     * subset, the finishOne method should be called after finishing
     * all elements in some subset.
     *
     */
    static abstract class OneSubsetProcessor{
	double myTime;

	public void startAll(){
	    myTime = System.currentTimeMillis();
	}

	public void finishAll(){
	    myTime = System.currentTimeMillis() - myTime;
	}
	public double getTime(){
	    return myTime/1000;
	}

	/**
	 * Called by subset generator with each element
	 * in one subset. To process a complete subset,
	 * methods doOne() and finishOne() should work
	 * together, e.g., finishOne() called after processing
	 * all elements.
	 */
	public abstract void doOne(Object o);
	public abstract void finishOne();

    }

    /**
     * Generate all subsets, the list of elements from
     * which subsets are generated is set via setList
     * or at construction time.
     * Each different generator will generate all subsets
     * via the method <code>process</code> and process subsets
     * by that methods processor parameter.
     */

    static abstract class SubsetGenerator{
	List myList;

	public SubsetGenerator(List list){
	    myList = list;
	}

	public void setList(List list){
	    myList = list;
	}

	public abstract void process(OneSubsetProcessor thing);
    }

    /**
     * Generate all subsets recursively.
     */
    static class RecursiveSubsetGenerator extends SubsetGenerator {

	OneSubsetProcessor myThing;
	public RecursiveSubsetGenerator(List list){
	    super(list);
	}

	public void process(OneSubsetProcessor thing){
	    myThing = thing;
	    ArrayList list = new ArrayList();
	    myThing.startAll();
	    doGenerate(list,0);
	    myThing.finishAll();
	}

	protected void doGenerate(ArrayList list, int index){
	    if (index >= myList.size()){
		for(int k=0; k < list.size(); k++){
		    myThing.doOne(list.get(k));
		}
		myThing.finishOne();
	    }
	    else {
		list.add(myList.get(index));
		doGenerate(list,index+1);
		list.remove(list.size()-1);
		doGenerate(list, index+1);
	    }
	}
    }

    /**
     * Generate all subsets via bit patterns.
     */
    static class BitSubsetGenerator extends SubsetGenerator {

	OneSubsetProcessor myThing;

	public BitSubsetGenerator(List list){
	    super(list);
	}

	public void process(OneSubsetProcessor thing){
	    myThing = thing;
	    int size = 1 << myList.size();
	    myThing.startAll();
	    for(int k=0; k < size; k++){
		doProcess(k);
	    }
	    myThing.finishAll();
	}

	protected void doProcess(int bits){
	    int size = myList.size();
	    for(int k=0; k < size; k++){
		if ( (bits & 1) == 1){
		    myThing.doOne(myList.get(k));
		}
		bits = bits >> 1;
	    }
	    myThing.finishOne();
	}
    }

    /**
     * Counts subsets, note that doOne() does nothing.
     */
    static class Counter extends OneSubsetProcessor{
	int myCount;
	public Counter(){
	    myCount = 0;
	}
	public void startAll(){
	    super.startAll();
	    myCount = 0;
	}
	public void doOne(Object o){

	}
	public void finishOne(){
	    myCount++;
	}
    }

    /**
     * Prints subsets.
     */
    static class Printer extends OneSubsetProcessor{
	public void doOne(Object o){
	    System.out.print(o+" ");
	}
	public void finishOne(){
	    System.out.println();
	}
    }

    public static void main(String[] args){

	String[] array = {
	    "ant", "cat", "dog", "penguin", "lemur",
//	    "lion", "horse", "giraffe", "goat", "monkey",
//	    "zebra", "yak", "cougar", "tapir", "mongoose",
//	    "tiger", "kangaroo", "leopard", "cheetah", "ostrich",
//	    "antelope", "narwhal", "unicorn"
	};
	List list = Arrays.asList(array);
	SubsetGenerator sgr = new RecursiveSubsetGenerator(list);
	SubsetGenerator sgb = new BitSubsetGenerator(list);
	OneSubsetProcessor st = new Printer();
	Counter ct = new Counter();

	sgr.process(ct);
	sgb.process(st);
	System.out.println("count = " + ct.myCount);
	System.out.println("time = "+ct.getTime());
    } 

}

Hail Steve !!

http://stefan-pochmann.info/spots/

http://www.cs.duke.edu/courses/fall04/cps100/code/sorting/SubsetStuff.java